@cocreate/file 1.1.0 → 1.2.1

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+## [1.2.1](https://github.com/CoCreate-app/CoCreate-file/compare/v1.2.0...v1.2.1) (2023-06-10)
+
+
+### Bug Fixes
+
+* Refactor authentication & update config file output format ([27da6f0](https://github.com/CoCreate-app/CoCreate-file/commit/27da6f06c832bb3e153074a96a42017f0f0a3c30))
+
+# [1.2.0](https://github.com/CoCreate-app/CoCreate-file/compare/v1.1.0...v1.2.0) (2023-06-09)
+
+
+### Bug Fixes
+
+* Update dependencies versions for [@cocreate](https://github.com/cocreate) libraries ([c86d68d](https://github.com/CoCreate-app/CoCreate-file/commit/c86d68d3ef7fa76e8f52867f7abecaa67bab8270))
+
+
+### Features
+
+* client and server functions ([af50769](https://github.com/CoCreate-app/CoCreate-file/commit/af5076902607f52c51f5a4fcca4a4a5554617b92))
+
 # [1.1.0](https://github.com/CoCreate-app/CoCreate-file/compare/v1.0.0...v1.1.0) (2023-06-08)
 
 

package/CoCreate.config.js

@@ -1,9 +1,7 @@
 module.exports = {
-    "config": {
-        "organization_id": "",
-        "key": "",
-        "host": ""
-    },
+    "organization_id": "",
+    "key": "",
+    "host": "",
     "sources": [
         {
             "collection": "files",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/file",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "A headless file uploader that uses HTML5 attributes for customization. Allows easy upload of files to server.",
   "keywords": [
     "file",
@@ -29,7 +29,7 @@
     "build": "NODE_ENV=production npx webpack --config webpack.config.js",
     "dev": "npx webpack --config webpack.config.js --watch",
     "docs": "node ./node_modules/@cocreate/docs/src/index.js",
-    "postinstall": "node ./node_modules/@cocreate/cli/check-coc.js"
+    "postinstal": "node ./node_modules/@cocreate/cli/check-coc.js"
   },
   "repository": {
     "type": "git",

package/src/client.js

@@ -0,0 +1,318 @@
+import observer from '@cocreate/observer';
+import crud from '@cocreate/crud-client';
+import action from '@cocreate/actions';
+import render from '@cocreate/render';
+import '@cocreate/element-prototype';
+
+let inputs = new Map();
+
+function init(elements) {
+    // Returns an array of elements.
+    if (!elements)
+        elements = document.querySelectorAll('[type="file"]')
+
+    // If elements is an array of elements returns an array of elements.
+    else if (!Array.isArray(elements))
+        elements = [elements]
+    for (let i = 0; i < elements.length; i++) {
+        if (elements[i].tagName !== 'INPUT') {
+            // TODO: create input and append to div if input dos not exist
+        }
+        elements[i].getValue = async () => await getSelectedFiles([elements[i]], true)
+
+        // elements[i].setValue = (value) => pickr.setColor(value);
+        if (elements[i].hasAttribute('directory')) {
+            if (window.showDirectoryPicker)
+                elements[i].addEventListener("click", selectDirectory);
+            else if ('webkitdirectory' in elements[i]) {
+                elements[i].webkitdirectory = true
+                elements[i].addEventListener("change", handleFileInputChange)
+            } else
+                console.error("Directory selection not supported in this browser.");
+        } else if (window.showOpenFilePicker)
+            elements[i].addEventListener("click", selectFile);
+        else
+            elements[i].addEventListener("change", handleFileInputChange);
+    }
+}
+
+
+function handleFileInputChange(event) {
+    const input = event.target;
+    const files = input.files;
+    let selected = inputs.get(input) || []
+    selected.push(...files)
+    inputs.set(input, selected);
+    console.log("Files selected:", files);
+    renderFiles(input)
+}
+
+async function selectFile(event) {
+    event.preventDefault()
+    const input = event.target;
+    let selected = inputs.get(input) || []
+    try {
+        const multiple = input.multiple
+        const selectedFiles = await window.showOpenFilePicker({ multiple });
+
+        for (const handle of selectedFiles) {
+            selected.push(handle)
+        }
+
+        if (selected.length) {
+            inputs.set(input, selected);
+            console.log("Files selected:", selected);
+            renderFiles(input)
+        }
+
+    } catch (error) {
+        if (error.name !== 'AbortError') {
+            console.error("Error selecting files:", error);
+        }
+    }
+}
+
+async function selectDirectory(event) {
+    event.preventDefault()
+    const input = event.target;
+    let selected = inputs.get(input) || []
+
+    try {
+        const handle = await window.showDirectoryPicker();
+        selected.push(handle)
+
+        if (selected.length) {
+            inputs.set(input, selected);
+            console.log("Directory selected:", selected);
+            renderFiles(input)
+        }
+    } catch (error) {
+        if (error.name !== 'AbortError') {
+            console.error("Error selecting directory:", error);
+        }
+    }
+}
+
+async function getNewFileHandle() {
+    // const options = {
+    //     types: [
+    //         {
+    //             description: 'Text Files',
+    //             accept: {
+    //                 'text/plain': ['.txt'],
+    //             },
+    //         },
+    //     ],
+    // };
+    const handle = await window.showSaveFilePicker(options);
+    return handle;
+}
+
+async function getSelectedFiles(fileInputs, isObject) {
+    const files = [];
+
+    if (!Array.isArray(fileInputs))
+        fileInputs = [fileInputs]
+
+    for (let input of fileInputs) {
+        const selected = inputs.get(input) || []
+
+        for (let i = 0; i < selected.length; i++) {
+            let file
+            if (selected[i] instanceof FileSystemDirectoryHandle) {
+                // The object is an instance of FileSystemFileHandle
+                const handles = await getSelectedDirectoryFiles(selected[i], selected[i].name)
+                for (let handle of handles) {
+                    if (handle.kind === 'file')
+                        file = await handle.getFile();
+                    else if (handle.kind === 'directory')
+                        file = { ...handle, name: handle.name }
+                    else continue
+
+                    if (isObject)
+                        file = await readFile(file)
+
+                    files.push(file)
+                }
+            } else {
+                if (selected[i] instanceof FileSystemFileHandle) {
+                    // The object is an instance of FileSystemFileHandle
+                    file = await selected[i].getFile();
+                } else {
+                    // The object is not an instance of FileSystemFileHandle
+                    console.log("It's not a FileSystemFileHandle object");
+                    file = selected[i]
+                }
+
+                if (isObject)
+                    file = await readFile(file)
+
+                files.push(file)
+            }
+
+        }
+    }
+
+    return files
+}
+
+async function getSelectedDirectoryFiles(handle, name) {
+    let files = [];
+    for await (const entry of handle.values()) {
+        entry.directory = '/' + name
+        entry.parentDirectory = name.split("/").pop();
+        entry.path = '/' + name + '/' + entry.name
+        if (!entry.webkitRelativePath)
+            entry.webkitRelativePath = name
+
+        if (entry.kind === 'file') {
+            files.push(entry);
+        } else if (entry.kind === 'directory') {
+            entry.type = 'text/directory'
+            files.push(entry);
+            const entries = await getSelectedDirectoryFiles(entry, name + '/' + entry.name);
+            files = files.concat(entries);
+        }
+    }
+    return files;
+}
+
+// This function reads the file and returns its src
+function readFile(file) {
+    // Return a new promise that resolves the file object
+    return new Promise((resolve) => {
+        file["content-type"] = file.type
+
+        // Split the file type into an array
+        const fileType = file.type.split('/');
+        let readAs;
+
+        // Check if the file type is a directory
+        if (fileType[1] === 'directory') {
+            return resolve(file)
+        }
+        // Check if the file type is a image
+        else if (['jpg', 'jpeg', 'png', 'gif', 'bmp'].includes(fileType[1])
+            || fileType[0] === 'image') {
+            readAs = 'readAsDataURL';
+        }
+        // Check if the file type is a video
+        else if (['mp4', 'avi', 'mov', 'mpeg', 'flv'].includes(fileType[1])
+            || fileType[0] === 'video') {
+            readAs = 'readAsDataURL';
+        }
+        // Check if the file type is an audio
+        else if (['mp3', 'wav', 'wma', 'aac', 'ogg'].includes(fileType[1])
+            || fileType[0] === 'audio') { // updated condition
+            readAs = 'readAsDataURL';
+        }
+        // Check if the file type is a pdf
+        else if (fileType[1] === 'pdf') {
+            readAs = 'readAsDataURL';
+        }
+        // Check if the file type is a document
+        else if (['doc', 'msword', 'docx', 'xlsx', 'pptx'].includes(fileType[1])) {
+            readAs = 'readAsBinaryString';
+        }
+        // Otherwise, assume the file type is text
+        else {
+            readAs = 'readAsText';
+        }
+
+        // Create a FileReader instance to read the file
+        const reader = new FileReader();
+        // Read the file based on the file type
+        reader[readAs](file);
+        // When the file is loaded, resolve the file object
+        reader.onload = () => {
+            file.src = reader.result;
+            // If the file type is a document, convert it to base64 encoding
+            if (['doc', 'msword', 'docx', 'xlsx', 'pptx'].includes(fileType)) {
+                file.src = btoa(file.src);
+            }
+
+            // Resolve the file object
+            resolve(file);
+        };
+    });
+}
+
+async function fileAction(btn, params, action) {
+    const form = btn.closest('form')
+    let inputs = form.querySelectorAll('input[type="file"]')
+    let fileObjects = await getSelectedFiles(Array.from(inputs), true)
+
+    console.log('fileObjects', fileObjects)
+    document.dispatchEvent(new CustomEvent(action, {
+        detail: {}
+    }));
+
+}
+
+// may be best to use getValue() so form so inputtype files can be can be managed in forms
+async function save(inputs, collection, document_id) {
+    let files = await getSelectedFiles(inputs, true)
+
+    let response = await crud.updateDocument({
+        collection,
+        document: files,
+        upsert: true
+    });
+
+    if (response && (!document_id || document_id !== response.document_id)) {
+        crud.setDocumentId(element, collection, response.document_id);
+    }
+
+    return response
+}
+
+async function getFiles(inputs) {
+    let files = await getSelectedFiles(inputs)
+    return files
+}
+
+async function getObjects(inputs) {
+    let objects = await getSelectedFiles(inputs, true)
+    return objects
+}
+
+function renderFiles(input) {
+    // TODO: support 
+    let template_id = input.getAttribute('template_id')
+    if (template_id) {
+        // if data items are handle it will not yet have all the details 
+        const data = inputs.get(input)
+        if (data.length) return
+        render.data({
+            selector: `[template='${template_id}']`,
+            data
+        });
+    }
+}
+
+observer.init({
+    name: 'CoCreateFileAddedNodes',
+    observe: ['addedNodes'],
+    target: 'input[type="file"]',
+    callback: mutation => init(mutation.target)
+
+});
+
+observer.init({
+    name: 'CoCreateFileAttributes',
+    observe: ['attributes'],
+    attributeName: ['type'],
+    target: 'input[type="file"]',
+    callback: mutation => init(mutation.target)
+});
+
+action.init({
+    name: "upload",
+    callback: (btn, params) => {
+        fileAction(btn, params, "upload")
+    }
+})
+
+init()
+
+export default { getFiles, getObjects }

package/src/server.js

@@ -0,0 +1,354 @@
+const crud = require('@cocreate/crud-client')
+const cli = require('@cocreate/cli')
+const mime = require('mime-types')
+const fs = require('fs');
+const path = require('path');
+
+
+module.exports = async function file(CoCreateConfig) {
+
+    let configFile = path.resolve(process.cwd(), 'CoCreate.config.js');
+    if (fs.existsSync(configFile)) {
+        CoCreateConfig = require(configFile);
+    } else {
+        console.log('CoCreate.config.js could not be found.')
+        process.exit()
+    }
+
+    let { directories, sources } = CoCreateConfig;
+    let config = await cli.config([
+        {
+            key: 'organization_id',
+            prompt: 'Enter your organization_id: '
+        }, {
+            key: 'host',
+            prompt: 'Enter the host: '
+        }, {
+            prompt: 'Choose an authentication option: \n1.key\n2.Sign In\n',
+            choices: {
+                '1': {
+                    key: 'key',
+                    prompt: 'Enter your key: '
+                },
+                '2': [
+                    {
+                        key: 'email',
+                        prompt: 'Enter your email: '
+                    },
+                    {
+                        key: 'password',
+                        prompt: 'Enter your password: '
+                    }
+                ]
+            }
+        }
+    ])
+
+    if (!config.organization_id || !config.host || !config.key && (!config.password || config.email)) {
+        console.log('One or more required config params could not be found')
+        process.exit()
+    }
+
+
+    crud.socket.create(config)
+    config.broadcast = false
+
+    if (config.email && config.password) {
+        let request = {
+            collection: 'users',
+            filter: {
+                query: [
+                    { name: 'email', value: config.email, operator: '$eq' },
+                    { name: 'password', value: config.password, operator: '$eq' }
+                ]
+            }
+        }
+
+        let response = await crud.socket.send('signIn', request)
+        let { success, token } = response;
+
+        if (success) {
+            console.log('succesful sign in')
+            // apply token to socket
+        } else {
+            console.log('The email or password you entered is incorrect')
+            process.exit()
+
+        }
+
+    }
+
+    console.log('Uploading files...')
+
+    /**
+     * Store files by config directories
+     **/
+    let errorLog = [];
+
+    async function runDirectories() {
+        for (const directory of directories) {
+            const entry = directory.entry
+            const exclude = directory.exclude
+            await runFiles(directory, entry, exclude)
+        }
+        return
+    }
+
+    async function runFiles(directory, entry, exclude, parentDirectory = '') {
+        let files = fs.readdirSync(entry);
+
+        for (let file of files) {
+            if (exclude && exclude.includes(file)) continue
+
+            let isDirectory = fs.existsSync(`${entry}/${file}`) && fs.lstatSync(`${entry}/${file}`).isDirectory();
+            let name = file
+            let source = ''
+            let directoryName = parentDirectory || '';
+            let parentDirectoryOnly = parentDirectory || '';
+            let index = parentDirectoryOnly.lastIndexOf('/') + 1
+            if (parentDirectoryOnly && index) {
+                parentDirectoryOnly = parentDirectoryOnly.substring(index)
+            }
+            let mimeType = mime.lookup(`${file}`)
+            let pathName = '';
+
+            if (!directoryName && directory.document && directory.document.directory)
+                directoryName = directory.document.directory.replace('{{directory}}', '').trim()
+            else if (!directoryName)
+                directoryName = '/'
+
+            if (exclude && exclude.includes(directoryName)) continue
+
+            if (directoryName.endsWith("/"))
+                pathName = directoryName + name
+            else if (directoryName)
+                pathName = directoryName + '/' + name
+            else
+                pathName = '/' + name
+
+            if (exclude && exclude.includes(pathName)) continue
+
+            if (isDirectory)
+                mimeType = "text/directory"
+            else
+                source = getSource(`${entry}/${file}`, mimeType)
+
+            let values = {
+                '{{name}}': name,
+                '{{source}}': source,
+                '{{directory}}': directoryName,
+                '{{parentDirectory}}': parentDirectoryOnly,
+                '{{path}}': pathName,
+                '{{content-type}}': mimeType
+            }
+
+            let document = { ...directory.document }
+            if (!document.name)
+                document.name = "{{name}}"
+            if (!document.src)
+                document.src = "{{source}}"
+            if (!document.directory)
+                document.directory = "/{{directory}}"
+            if (!document.parentDirectory)
+                document.parentDirectory = "{{parentDirectory}}"
+            if (!document.path)
+                document.path = "{{path}}"
+            if (!document["content-type"])
+                document["content-type"] = '{{content-type}}'
+            if (!document.public && document.public != false && document.public != 'false')
+                document.public = 'true'
+
+            let object = {
+                collection: directory.collection || 'files',
+                document
+            }
+            for (const key of Object.keys(directory.document)) {
+                if (typeof directory.document[key] == 'string') {
+
+                    let variables = directory.document[key].match(/{{([A-Za-z0-9_.,\[\]\-\/ ]*)}}/g);
+                    if (variables) {
+                        for (let variable of variables) {
+                            if (variable == '{{directory}}') {
+                                if (parentDirectory)
+                                    object.document[key] = values[variable]
+                                else
+                                    object.document[key] = object.document[key].replace(variable, '');
+                            }
+                            else if (isDirectory && variable == '{{source}}')
+                                delete object.document[key]
+                            else
+                                object.document[key] = object.document[key].replace(variable, values[variable]);
+                        }
+                    }
+
+                }
+            }
+
+            if (!object.document._id)
+                object.filter = {
+                    query: [{ name: 'path', value: pathName, operator: '$eq' }]
+                }
+
+            response = await runStore(object);
+            if (response.error)
+                errorLog.push(response.error)
+
+            if (isDirectory && pathName) {
+                let newEntry
+                if (entry.endsWith("/"))
+                    newEntry = entry + name
+                else
+                    newEntry = entry + '/' + name
+
+                await runFiles(directory, newEntry, exclude, pathName)
+            }
+        }
+        if (errorLog.length)
+            console.log(...errorLog)
+
+    }
+
+
+    function getSource(path, mimeType) {
+        let readType = 'utf8'
+        if (/^(image|audio|video)\/[-+.\w]+/.test(mimeType))
+            readType = 'base64'
+
+        let binary = fs.readFileSync(path);
+        let content = new Buffer.from(binary).toString(readType);
+
+        return content
+    }
+
+    /**
+     * Store files by config sources
+     **/
+    async function runSources() {
+        let updatedSources = [];
+
+        for (let i = 0; i < sources.length; i++) {
+            const { collection, document } = sources[i];
+
+            let source = { ...sources[i] };
+            let keys = new Map()
+            let response = {};
+
+            try {
+                if (collection) {
+                    if (!document)
+                        document = {};
+                    else
+                        for (const key of Object.keys(document)) {
+                            if (typeof document[key] != 'string')
+                                continue
+
+                            let variables = document[key].match(/{{([A-Za-z0-9_.,\[\]\-\/ ]*)}}/g);
+                            if (variables) {
+                                keys.set(key, `${document[key]}`)
+                                let value = ""
+                                for (let variable of variables) {
+                                    let entry = /{{\s*([\w\W]+)\s*}}/g.exec(variable);
+                                    entry = entry[1].trim()
+                                    if (entry) {
+                                        if (!fs.existsSync(entry))
+                                            continue
+
+                                        let read_type = 'utf8'
+                                        let mime_type = mime.lookup(entry) || 'text/html';
+                                        if (/^(image|audio|video)\/[-+.\w]+/.test(mime_type)) {
+                                            read_type = 'base64'
+                                        }
+
+                                        let binary = fs.readFileSync(entry);
+                                        let content = new Buffer.from(binary).toString(read_type);
+                                        if (content)
+                                            value += content
+                                        // document[key] = document[key].replace(variable, content);
+                                    }
+                                }
+                                document[key] = value
+                            }
+
+                        }
+
+                    let data = { collection, document }
+                    if (!document._id && document.path)
+                        data.filter = {
+                            query: [{ name: 'path', value: document.path, operator: '$eq' }]
+                        }
+
+                    response = await runStore(data);
+                }
+            } catch (err) {
+                console.log(err)
+                process.exit()
+            }
+            if (response.document && response.document[0] && response.document[0]._id) {
+                for (const [key, value] of keys) {
+                    source.document[key] = value
+                }
+                source.document._id = response.document[0]._id
+            } else {
+                console.log('_id could not be found')
+                process.exit()
+            }
+
+            updatedSources.push(source)
+        }
+
+        return updatedSources
+    }
+
+
+    async function runStore(data) {
+        try {
+            let response;
+            if (!data.document._id && !data.filter) {
+                response = await crud.createDocument({
+                    ...config,
+                    ...data
+                })
+            } else {
+                response = await crud.updateDocument({
+                    ...config,
+                    ...data,
+                    upsert: true
+                })
+            }
+            if (response) {
+                return response;
+            }
+        } catch (err) {
+            console.log(err);
+            return null;
+        }
+    }
+
+    async function run() {
+        if (directories)
+            await runDirectories()
+
+        if (sources) {
+            let sources = await runSources()
+            let newConfig = { ...CoCreateConfig }
+            if (directories)
+                newConfig.directories = directories
+
+            newConfig.sources = sources
+
+            delete newConfig.url
+            delete newConfig.broadcast
+            const write_str = `module.exports = ${JSON.stringify(newConfig, null, 4)};`;
+
+            fs.writeFileSync(configFile, write_str);
+        }
+
+        console.log('upload complete!');
+
+        setTimeout(function () {
+            process.exit()
+        }, 2000)
+    }
+
+    run()
+}