mango-cms 0.0.13

package/src/default-config/plugins/mango-stand/index.js

@@ -0,0 +1,206 @@
+// import CMS from '../../../mango/src/cms' (for use like {address: CMS.fields.Address()})
+import fields from '@cms/1. build/fields'
+import { readEntries, readEntry } from '../../../mango/src/cms/1. build/libraries/mongo'
+
+const billing = {
+    fields: {
+        paymentId: String,
+        firstName: { type: String, search: { enabled: true, weight: 5 } },
+        lastName: { type: String, search: { enabled: true, weight: 5 } },
+        phoneNumber: String,
+        address: fields.Address(),
+        payment: {
+            fields: {
+                creditCard: {
+                    fields: {
+                        cardNumber: String,
+                        cardType: String,
+                        expirationDate: String,
+                    }
+                },
+                bankAccount: {
+                    fields: {
+                        accountNumber: String,
+                        accountType: String,
+                        echeckType: String,
+                        nameOnAccount: String,
+                        routingNumber: String
+                    }
+                }
+            }
+        }
+    }
+}
+
+const Items = {
+    name: 'items',
+    singular: 'item',
+    fields: {
+        price: { type: 'Int' },
+        stock: { type: 'Int' },
+        description: fields.PlainText(),
+    },
+    hooks: {
+        sold({ item }) {
+            console.log('sold', item.title)
+        },
+        addedToCart({ item }) {
+            console.log('addedToCart', item.title)
+        },
+        removedFromCart({ item }) {
+            console.log('removedFromCart', item.title)
+        }
+    }
+}
+
+const Discounts = {
+    name: 'discounts',
+    singular: 'discount',
+    permissions: {
+        public: ['create', 'read']
+    },
+    fields: {
+        type: fields.Select({ options: ['coupon', 'sale'], required: true }),
+        code: { required: true, translateInput: i => i.toLowerCase() },
+        limitations: {
+            fields: {
+                items: fields.Relationship({ collection: 'item' }),
+                perCustomer: 'Int',
+                totalUses: 'Int',
+                perOrder: 'Int',
+                quantity: 'Int',
+                // remainingUses: {
+                //     computed: doc => doc.limitations.totalUses ? /* Get times used and subtract from total uses */ : null
+                // }
+            }
+        },
+        freeShipping: Boolean,
+        discount: {
+            inputExample: '$12.50 or 50% etc.',
+            inputType: String,
+            validate: input => ({ valid: (!!input.match(/\$[0-9]+/) || input.match(/[0-9]\%+/)) ? true : false, response: 'Should be formatted like `100%` or `$12.50`' }),
+            translateInput: input => ({
+                type: !!input.match(/\$[0-9]+/) ? 'fixed' : 'percentage',
+                value: !!input.match(/\$[0-9]+/) ? input.match(/\$\d+(?:\.\d+)?/)[0].replace('$', '') : input.match(/(\d+|\d+[.,]\d{1,2})(?=\s*%)/)[0].replace('%', '')
+            }),
+            fields: {
+                type: String,
+                value: 'Float'
+            }
+        }
+    }
+}
+
+
+const Carts = {
+    name: 'carts',
+    singular: 'cart',
+    permissions: {
+        public: ['create', 'read', 'update']
+    },
+    fields: {
+
+        title: { required: false },
+
+        transactionId: String,
+        finalized: Boolean,
+        completed: Boolean,
+        completedDate: fields.Timestamp(),
+        cartItems: [{
+            fields: {
+                quantity: 'Int',
+                discount: 'Float',
+                item: fields.Relationship({ collection: 'item', single: true }),
+            }
+        }],
+        coupons: fields.Relationship({ collection: 'discount' }),
+
+        customerId: String,
+        billing,
+        shipping: {
+            fields: {
+                method: String,
+                price: String,
+                addressId: String,
+                firstName: String,
+                lastName: String,
+                phoneNumber: String,
+                address: fields.Address(),
+                free: { type: Boolean, computed: doc => doc?.coupons?.find(c => c.freeShipping) }
+            }
+        },
+
+        price: {
+            fields: {
+                subtotal: 'Float',
+                discount: 'Float',
+                total: 'Float',
+            },
+            computed: async doc => {
+
+                let subtotal = Number(doc.cartItems?.reduce((a, i) => a + ((i.item?.price || 0) * i.quantity), 0)) || 0
+                let shipping = doc?.shipping?.price || 0
+
+                let discount = 0
+
+                if (doc?.coupons?.length) {
+                    let coupon = doc?.coupons?.[0]
+                    if (coupon?.limitations?.items) {
+                        for (let item of doc.cartItems) {
+                            if (coupon?.limitations?.items?.find(i => i.id == item.item?.id)) {
+                                if (coupon.discount.type == 'fixed') {
+                                    discount += (item.quantity * coupon.discount.value)
+                                } else {
+                                    discount += ((item.quantity * item.item.price) * (Number(coupon.discount.value) / 100))
+                                    console.log('discount', discount)
+                                }
+                            }
+                        }
+                    } else {
+                        if (coupon.discount.type == 'fixed') {
+                            discount = Number(coupon.discount.value > subtotal ? subtotal : coupon.discount.value)
+                        } else {
+                            discount = Number(subtotal * (Number(coupon.discount.value) / 100))
+                        }
+                    }
+                }
+
+                let activeSales = await readEntries({ collection: 'discounts', search: { type: 'sale', startDate: { $lt: new Date() }, endDate: { $gt: new Date() } } })
+
+                if (activeSales?.length) {
+                    for (let item of doc.cartItems) {
+                        for (let sale of activeSales.sort((a, b) => b.discount.value < a.discount.value ? 1 : -1)) {
+                            let saleApplies = sale?.limitations?.items?.some(i => i == item.item?.id) || !sale?.limitations?.items?.length
+                            if (saleApplies) {
+                                if (sale.discount.type == 'fixed') {
+                                    item.discount = (item.quantity * sale.discount.value)
+                                } else {
+                                    item.discount = Number((item.quantity * item.item.price) * (Number(sale.discount.value) / 100))
+                                }
+                            }
+                        }
+                    }
+                    discount = Number(doc.cartItems?.reduce((a, i) => a + i.discount, 0))
+                }
+
+                let total = (subtotal + shipping - discount) || 0
+
+                return {
+                    subtotal,
+                    discount,
+                    total,
+                }
+            }
+        }
+
+    },
+}
+
+export default {
+    name: 'mangoStand',
+    collections: [
+        Items,
+        Carts,
+        Discounts,
+    ],
+}

package/src/main.js

@@ -0,0 +1,278 @@
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import ncp from 'ncp';
+import spawn from 'await-spawn'
+import { promisify } from 'util';
+import path from 'path';
+
+
+const child_process = require('child_process')
+
+const copy = promisify(ncp);
+
+async function copyConfigFiles(options) {
+    const excludeDir = 'dist';
+
+    // Filter function to exclude the dist directory
+    const filterFunc = (src, dest) => {
+        // Use relative path for accurate exclusion when running in nested directories
+        const relativePath = src.substring(options.projectConfigDirectory.length);
+
+        // Exclude the 'dist' directory and its contents
+        if (relativePath.startsWith(`/${excludeDir}`) || relativePath === excludeDir) {
+            return false;
+        }
+
+        return true;
+    };
+
+    // Copy files
+    await fs.copy(options.projectConfigDirectory, options.mangoConfigDirectory, {
+        clobber: true,
+        filter: filterFunc
+    });
+
+    // Path to settings.json
+    const settingsFilePath = path.join(options.mangoConfigDirectory, 'config', 'settings.json');
+
+    // Read, modify, and write settings.json
+    try {
+        // Read settings.json
+        const settings = await fs.readJson(settingsFilePath);
+
+        // Modify settings.json
+        settings.projectConfigDirectory = options.projectConfigDirectory;
+
+        // Write updated settings.json
+        await fs.writeJson(settingsFilePath, settings, { spaces: 4 });
+    } catch (error) {
+        console.error('Error updating settings.json:', error);
+        throw error;
+    }
+}
+
+async function installMango() {
+
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = currentFileUrl.replace('file://', '').replace('/main.js', '')
+    const mangoDirectory = `${currentFilePath}/../mango`
+
+    // Make sure mango exists
+    if (!fs.existsSync(mangoDirectory)) {
+        console.log('installing mango')
+        await spawn('git', ['clone', 'git@github.com:colton-neifert/mango-cms.git'], { cwd: `${currentFilePath}/../` })
+        const sourceFolderPath = path.join(`${currentFilePath}/../`, 'mango-cms');
+        const targetFolderPath = path.join(`${currentFilePath}/../`, 'mango');
+        fs.renameSync(sourceFolderPath, targetFolderPath);
+        await spawn('yarn', { cwd: `${currentFilePath}/../mango` })
+    } else {
+        // Get latest mango
+        console.log('checking version...')
+        let pullResponse = await spawn('git', ['pull'], { cwd: `${currentFilePath}/../mango` })
+        let upToDate = pullResponse.toString().includes('Already')
+
+        if (!upToDate) {
+            console.log('updating dependencies')
+            await spawn('yarn', { cwd: `${currentFilePath}/../mango` })
+        }
+    }
+}
+
+export async function serveMango(options) {
+
+    options = {
+        ...options,
+        targetDirectory: options.targetDirectory || process.cwd(),
+    };
+
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = currentFileUrl.replace('file://', '').replace('/main.js', '')
+    const mangoDirectory = `${currentFilePath}/../mango`
+    const mangoConfigDirectory = `${currentFilePath}/../config`
+
+    let projectConfigDirectory = `${options.targetDirectory}/mango`
+
+    // Check if mango config exists
+    if (!fs.existsSync(projectConfigDirectory)) {
+        const collectionsDirectory = `${options.targetDirectory}/collections`;
+
+        // Check if collections directory exists inside targetDirectory
+        if (fs.existsSync(collectionsDirectory)) {
+            // Set projectConfigDirectory to targetDirectory
+            projectConfigDirectory = options.targetDirectory;
+        } else {
+            // If neither mango config nor collections directory exists
+            console.error('%s Mango config not found. Please add mango config to ./mango', chalk.red.bold('ERROR'));
+            process.exit(1);
+        }
+    }
+
+    options.projectConfigDirectory = projectConfigDirectory
+    options.mangoConfigDirectory = mangoConfigDirectory
+
+    await installMango()
+
+    let settings = fs.readFileSync(`${projectConfigDirectory}/config/settings.json`)
+    settings = JSON.parse(settings)
+
+    console.log('copying config files');
+    await copyConfigFiles(options);
+
+    console.log('spawning mango');
+    child_process.spawn('yarn', ['watch'], { cwd: `${mangoDirectory}` })
+    setTimeout(() => {
+        console.log(`%s Mango Running @ http://localhost:${settings.port}/graphql`, chalk.green.bold('DONE'));
+    }, 5000);
+    return true;
+}
+
+export async function buildMango(options) {
+
+    options = {
+        ...options,
+        targetDirectory: options.targetDirectory || process.cwd(),
+    };
+
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = currentFileUrl.replace('file://', '').replace('/main.js', '')
+    const mangoDirectory = `${currentFilePath}/../mango`
+    const mangoConfigDirectory = `${currentFilePath}/../config`
+
+    let projectConfigDirectory = `${options.targetDirectory}/mango`
+
+    // Check if mango config exists
+    if (!fs.existsSync(projectConfigDirectory)) {
+        const collectionsDirectory = `${options.targetDirectory}/collections`;
+
+        // Check if collections directory exists inside targetDirectory
+        if (fs.existsSync(collectionsDirectory)) {
+            // Set projectConfigDirectory to targetDirectory
+            projectConfigDirectory = options.targetDirectory;
+        } else {
+            // If neither mango config nor collections directory exists
+            console.error('%s Mango config not found. Please add mango config to ./mango', chalk.red.bold('ERROR'));
+            process.exit(1);
+        }
+    }
+
+    options.projectConfigDirectory = projectConfigDirectory
+    options.mangoConfigDirectory = mangoConfigDirectory
+
+    await installMango()
+
+    let settings = fs.readFileSync(`${projectConfigDirectory}/config/settings.json`)
+    settings = JSON.parse(settings)
+
+    console.log('copying config files');
+    await copyConfigFiles(options);
+
+    console.log('building mango');
+    await spawn('yarn', ['build'], { cwd: `${mangoDirectory}` })
+    // console.log('copying mango build', `${projectConfigDirectory}/dist/mango.js`);
+    // child_process.spawn('yarn', ['build'], { cwd: `${mangoDirectory}` })
+    if (!fs.existsSync(`${projectConfigDirectory}/dist`)) fs.mkdirSync(`${projectConfigDirectory}/dist`)
+    await copy(`${mangoDirectory}/node_modules`, `${projectConfigDirectory}/dist/node_modules`)
+    await copy(`${mangoDirectory}/build/index.js`, `${projectConfigDirectory}/dist/mango.js`)
+
+    console.log(`%s Mango build completed successfully.`, chalk.green.bold('DONE'));
+
+    return true;
+}
+
+export async function initMango(options) {
+
+    options = {
+        ...options,
+        targetDirectory: options.targetDirectory || process.cwd(),
+    };
+
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = currentFileUrl.replace('file://', '').replace('/main.js', '')
+    const defaultConfig = `${currentFilePath}/default-config`
+
+    const projectConfigDirectory = `${options.targetDirectory}/mango`
+
+    // Make sure mango config exists
+    if (fs.existsSync(projectConfigDirectory)) {
+        console.error('%s Mango already exists at ./mango', chalk.red.bold('ERROR'));
+        process.exit(1);
+    } else {
+        fs.mkdirSync(projectConfigDirectory);
+    }
+
+    // const mangoUiDirectory = `${currentFilePath}/../mango-ui`
+
+    await copy(defaultConfig, projectConfigDirectory)
+
+    /*
+    We're not actually moving mango to the project directory anymore
+    */
+    await installMango()
+    const mangoDirectory = `${currentFilePath}/../mango`
+    await copy(mangoDirectory, projectConfigDirectory + '/.mango')
+
+    // await copy(mangoUiDirectory, projectConfigDirectory)
+
+    console.log(`%s Mango Config Created @ ./mango`, chalk.green.bold('SUCCESS'));
+
+}
+
+
+export async function createMango(options) {
+
+    options = {
+        ...options,
+        targetDirectory: options.targetDirectory || process.cwd(),
+    };
+
+    // Env
+    const currentFileUrl = import.meta.url;
+    const currentFilePath = currentFileUrl.replace('file://', '').replace('/main.js', '')
+
+    // The copy of mango and config we'll transfer
+    const defaultConfig = `${currentFilePath}/default-config`
+    const mango = `${currentFilePath}/../mango`
+    const frontendStarter = `${currentFilePath}/../frontend-starter`
+
+    // This is the new project and its mango and config folders
+    const projectDirectory = `${options.targetDirectory}/${options.projectName}`
+    const projectConfigDirectory = `${projectDirectory}/config`
+    const projectMangoDirectory = `${projectDirectory}/mango`
+    const projectFrontDirectory = `${projectDirectory}/front`
+
+    // Make sure mango exists
+    await installMango()
+
+    // Make sure the new project folders exist
+    if (!fs.existsSync(projectDirectory)) fs.mkdirSync(projectDirectory)
+    if (!fs.existsSync(projectMangoDirectory)) fs.mkdirSync(projectMangoDirectory)
+    if (!fs.existsSync(projectConfigDirectory)) fs.mkdirSync(projectConfigDirectory)
+    if (!fs.existsSync(projectFrontDirectory)) fs.mkdirSync(projectFrontDirectory)
+
+    console.log(`installing mango in ${options.projectName}...`)
+
+    // Copy mango and the default config
+    await copy(mango, projectMangoDirectory)
+    await copy(defaultConfig, projectConfigDirectory)
+    await copy(frontendStarter, projectFrontDirectory)
+
+    console.log('')
+    console.log(`%s ${options.projectName} Created`, chalk.green.bold('SUCCESS'));
+
+    console.log('')
+    console.log('# Start new mango backend')
+    console.log(`cd ${options.projectName}`)
+    console.log('mango-cms dev')
+
+    console.log('')
+    console.log(`# You might want to change the db name in ${options.projectName}/config/config/settings.json`)
+
+    console.log('')
+    console.log('# Serve frontend')
+    console.log(`cd ${options.projectName}/front`)
+    console.log('yarn')
+    console.log('yarn dev')
+
+    console.log('')
+
+}