@fullstackunicorn/create-root 1.0.28 → 2.0.0

package/assets/root.fullstackunicorn.dev/assets/modules/sync.js

@@ -1,292 +0,0 @@
-import { app, fsa, axios, crypto, JSZip, Sender } from '#@/index.dep.js'
-import { auth } from '#@/modules/sync.auth.js'
-import { Local } from '#@/modules/sync.local.js'
-import { Tools } from '#@/modules/sync.tools.js'
-
-export class Sync {
-
-    constructor(init) {
-
-        this.def = init.def
-        this.tools = new Tools(init)
-        this.local = new Local(init)
-    }
-
-    getWorkspaceApp = () => {
-        const text = JSON.stringify(app, null, 2)
-        const buffer = Buffer.from(text, 'utf8')
-        const hash = this.tools.hash(buffer)
-        return {
-            relPath: 'config/app.json',
-            text,
-            buffer,
-            hash
-        }
-    }
-
-    runWorkspacePush = async (target) => {
-
-        this.def.spinner.start()
-        this.def.reportWorkspace(`🔥🔥🔥 Sync.runWorkspacePush:start`)
-
-        if (target) this.def.app.target = target
-
-        try {
-
-            const headers = {}
-            headers.Authorization = await auth.getToken()
-            this.def.reportWorkspace(`✅ workspace-token-obtained`)
-
-            const dataPush = {}
-            dataPush.clientId = this.def.app.clientId
-            dataPush.target = this.def.app.target
-            dataPush.manifest = await this.tools.getWorkspaceManifest()
-            const workspaceApp = this.getWorkspaceApp()
-            dataPush.manifest.files[workspaceApp.relPath] = workspaceApp.hash
-            dataPush.manifest.total = Object.keys(dataPush.manifest.files).length
-            this.def.reportWorkspace(`✅ workspace-manifest-created`)
-
-            this.def.reportWorkspace(`🛜 Send-workspace-push ${this.def.endpoints.workspacePush}`)
-
-            const response = await axios.post(this.def.endpoints.workspacePush, dataPush, { headers })
-
-            this.def.reportWorkspace(`🛜 Send-workspace-push-report-start`)
-            this.def.reportWorkspace(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
-            this.def.reportWorkspace(`🛜 Send-workspace-push-report-end`)
-
-            const plan = response?.data?.plan
-            if (!F3.obj.isGood(plan)) F3.throw(`missing-workspace-plan`)
-
-            await fsa.ensureFileDir(this.def.files.export.manifest)
-            await fsa.writeJSON(this.def.files.export.manifest, dataPush.manifest)
-            this.def.reportWorkspace(`✅ written-workspace-manifest \n💾 ${this.def.files.export.manifest}`)
-
-            await fsa.ensureFileDir(this.def.files.export.plan)
-            await fsa.writeJSON(this.def.files.export.plan, plan)
-            this.def.reportWorkspace(`✅ written-workspace-plan \n💾 ${this.def.files.export.plan}`)
-
-            if (plan.isAlreadyInSync) {
-                this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePush:success-already-in-sync`)
-                return true
-            }
-
-            const uploadPaths = Object.keys(F3.obj.safe(plan.upload))
-
-            if (!uploadPaths.length) {
-                this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePush:success-manifest-only`)
-                return true
-            }
-
-            const zip = new JSZip()
-
-            for (const relPath of uploadPaths) {
-                let buffer = null
-
-                if (relPath === workspaceApp.relPath) buffer = workspaceApp.buffer
-                else {
-                    const fullPath = `${this.def.workspace}/${relPath}`
-                    buffer = await fsa.readFile(fullPath)
-                }
-
-                if (!buffer) F3.throw(`workspace-zip-missing-file:${relPath}`)
-                zip.file(relPath, buffer)
-                this.def.reportWorkspace(`✅ ➕ zip ${relPath}`)
-            }
-
-            await fsa.safeRemove(this.def.files.export.workspaceZip)
-            await fsa.ensureFileDir(this.def.files.export.workspaceZip)
-            const bufferZip = await zip.generateAsync({ type: 'nodebuffer', compression: 'DEFLATE' })
-            await fsa.writeFile(this.def.files.export.workspaceZip, bufferZip)
-
-            this.def.reportWorkspace(`✅ written-workspace-zip \n💾 ${this.def.files.export.workspaceZip}`)
-
-            const payload = {}
-            payload.crypto = crypto
-            payload.fileEndpoint = this.def.endpoints.file
-            payload.chunkEndpoint = this.def.endpoints.chunk
-            payload.statusEndpoint = this.def.endpoints.status
-            payload.finalizeEndpoint = this.def.endpoints.finalize
-            const sender = new Sender(payload)
-
-            const upload = {}
-            upload.bytes = bufferZip
-            upload.target = this.def.app.target
-            upload.token = await auth.getToken()
-            upload.payload = {}
-            upload.payload.callback = 'workspace'
-            upload.payload.importId = plan.importId
-            upload.payload.clientId = this.def.app.clientId
-
-            this.def.reportWorkspace(`🛜 Send-workspace-zip ${this.def.endpoints.file}`)
-
-            const senderRes = await sender.upload(upload)
-
-            this.def.reportWorkspace(`🛜 Send-workspace-zip-report-start`)
-            this.def.reportWorkspace(`🛜 ${senderRes?.callback?.report.join('\n🛜 ')}`)
-            this.def.reportWorkspace(`🛜 Send-workspace-zip-report-end`)
-
-            if (senderRes?.callback?.isOk) this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePush:success`)
-            else this.def.writeWorkspace(target, `❌❌❌ Sync.runWorkspacePush:failed`)
-
-        } catch (e) {
-            this.def.writeWorkspace(target, `❌❌❌ Sync.runWorkspacePush:error`)
-            F3.catch.throw(e)
-        }
-
-    }
-
-    runConfig = async (target) => {
-        return await this.runWorkspacePush(target)
-    }
-
-    runPush = async (target) => {
-        return await this.runWorkspacePush(target)
-    }
-
-    runWorkspacePull = async (target) => {
-
-        this.def.spinner.start()
-        this.def.reportWorkspace(`🔥🔥🔥 Sync.runWorkspacePull:start`)
-
-        if (target) this.def.app.target = target
-
-        try {
-
-            const headers = {}
-            headers.Authorization = await auth.getToken()
-
-            const payload = {}
-            payload.clientId = this.def.app.clientId
-            payload.target = this.def.app.target
-
-            this.def.reportWorkspace(`🛜 Send-workspace-pull ${this.def.endpoints.workspacePull}`)
-
-            const response = await axios.post(this.def.endpoints.workspacePull, payload, {
-                headers,
-                responseType: 'arraybuffer'
-            })
-
-            const filePath = this.def.getPullFile(this.def.app.target)
-
-            await fsa.ensureFileDir(filePath)
-            await fsa.writeFile(filePath, response.data)
-
-            this.def.reportWorkspace(`✅ 💾 workspace-pull-written ${filePath}`)
-            this.def.writeWorkspace(target, `🔥🔥🔥 Sync.runWorkspacePull:success`)
-
-            return true
-
-        } catch (e) {
-            this.def.writeWorkspace(target, `❌❌❌ Sync.runWorkspacePull:error`)
-            F3.catch.throw(e)
-        }
-    }
-
-    runCleanup = async (kind = 'workspace') => {
-
-        this.def.spinner.start()
-        this.def.reportWorkspace(`🔥🔥🔥 Sync.runCleanup:start ${kind}`)
-
-        try {
-
-            const headers = {}
-            headers.Authorization = await auth.getToken()
-
-            const payload = {}
-            payload.clientId = this.def.app.clientId
-            payload.kind = kind
-
-            this.def.reportWorkspace(`🛜 Send-workspace-cleanup ${this.def.endpoints.workspaceCleanup}`)
-
-            const response = await axios.post(this.def.endpoints.workspaceCleanup, payload, { headers })
-
-            const report = F3.arr.safe(response?.data?.report)
-            if (report.length) {
-                this.def.reportWorkspace(`🛜 ${report.join('\n🛜 ')}`)
-            }
-
-            if (!response?.data?.isOk) F3.throw(`workspace-cleanup-failed:${kind}`)
-
-            this.def.writeWorkspace('local', `🔥🔥🔥 Sync.runCleanup:success ${kind}`)
-
-            return true
-
-        } catch (e) {
-            this.def.writeWorkspace('local', `❌❌❌ Sync.runCleanup:error ${kind}`)
-            F3.catch.throw(e)
-        }
-
-    }
-
-    runAssets = async (target) => {
-
-        this.def.spinner.start()
-        this.def.reportAssets(`🔥🔥🔥 Sync.runAssets:start`)
-        if (target) this.def.app.target = target
-
-        try {
-
-            const payload = {}
-            payload.clientId = this.def.app.clientId
-            payload.target = this.def.app.target
-
-            this.def.reportAssets(`🛜 Send-assets ${this.def.endpoints.assets}`)
-
-            const response = await axios.post(this.def.endpoints.assets, payload)
-
-            this.def.reportAssets(`🛜 Send-assets-report-start`)
-            this.def.reportAssets(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
-            this.def.reportAssets(`🛜 Send-assets-report-end`)
-
-            if (response?.data?.isOk) this.def.writeAssets(target, `🔥🔥🔥 Sync.runAssets:success`)
-            else this.def.writeAssets(target, `❌❌❌ Sync.runAssets:failed`)
-
-        } catch (e) {
-            this.def.writeAssets(target, `❌❌❌ Sync.runAssets:error`)
-            F3.catch.throw(e)
-        }
-
-    }
-
-    runWorkers = async (target) => {
-
-        this.def.spinner.start()
-        this.def.reportWorkers(`🔥🔥🔥 Sync.runWorkers:start`)
-        if (target) this.def.app.target = target
-
-        try {
-
-            const payload = {}
-            payload.clientId = this.def.app.clientId
-            payload.target = this.def.app.target
-
-            this.def.reportWorkers(`🛜 Send-workers ${this.def.endpoints.workers}`)
-
-            const response = await axios.post(this.def.endpoints.workers, payload)
-
-            if (response?.data?.isLocal) {
-
-                const local = {}
-                local.payload = response?.data?.local
-                local.target = this.def.app.target
-                local.app = app
-
-                await this.local.run(local)
-
-                this.def.writeWorkers(target, `🔥🔥🔥 Sync.runWorkers:success-local`)
-                return true
-            }
-
-            this.def.reportWorkers(`🛜 Send-workers-report-start`)
-            this.def.reportWorkers(`🛜 ${response?.data?.report.join('\n🛜 ')}`)
-            this.def.reportWorkers(`🛜 Send-workers-report-end`)
-
-            if (response?.data?.isOk) this.def.writeWorkers(target, `🔥🔥🔥 Sync.runWorkers:success`)
-            else this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:failed`)
-
-        } catch (e) {
-            this.def.writeWorkers(target, `❌❌❌ Sync.runWorkers:error`)
-            F3.catch.throw(e)
-        }
-    }
-}

package/assets/root.fullstackunicorn.dev/assets/modules/sync.local.js

@@ -1,117 +0,0 @@
-import { fsa, axios, crypto, Sender } from '#@/index.dep.js'
-import { auth } from '#@/modules/sync.auth.js'
-
-export class Local {
-
-    constructor(init) {
-        this.def = init.def
-    }
-
-    getManager = (app, target) => {
-
-        if (!F3.obj.isGood(app)) F3.throw('local-app-not-valid')
-        if (!F3.obj.isGood(app.manager)) F3.throw('local-manager-not-valid')
-        if (!F3.str.isGood(target)) F3.throw('local-target-not-valid')
-
-        const manager = app.manager[target]
-        if (!F3.str.isGood(manager)) F3.throw('local-manager-target-not-valid', { target })
-
-        const result = {}
-        result.file = `${manager}/sync/file`
-        result.chunk = `${manager}/sync/chunk`
-        result.status = `${manager}/sync/status`
-        result.finalize = `${manager}/sync/finalize`
-
-        return result
-    }
-
-    send = async ({ app, target, plan, manifest }) => {
-
-        try {
-
-            if (!F3.obj.isGood(plan)) F3.throw('local-plan-not-valid')
-            if (!F3.obj.isGood(manifest)) F3.throw('local-manifest-not-valid')
-
-            const endpoints = this.getManager(app, target)
-
-            const payload = {}
-            payload.crypto = crypto
-            payload.fileEndpoint = endpoints.file
-            payload.chunkEndpoint = endpoints.chunk
-            payload.statusEndpoint = endpoints.status
-            payload.finalizeEndpoint = endpoints.finalize
-            const sender = new Sender(payload)
-
-            const upload = {}
-            upload.bytes = await fsa.readFile(this.def.files.export.volumeZip)
-            upload.target = target
-            upload.token = await auth.getToken()
-            upload.payload = {}
-            upload.payload.plan = plan
-            upload.payload.manifest = manifest
-
-            this.def.reportWorkers(`🛜 Send-local-manager-zip ${payload.fileEndpoint}`)
-
-            const response = await sender.upload(upload)
-
-            this.def.reportWorkers(`🛜 Send-local-manager-zip-report-start`)
-            this.def.reportWorkers(`🛜 💾 ${response?.callback?.written.join('\n🛜 💾 ')}`)
-            this.def.reportWorkers(`🛜 🗑️ ${response?.callback?.deleted.join('\n🛜 🗑️ ')}`)
-            this.def.reportWorkers(`🛜 Send-local-manager-zip-report-end`)
-
-            if (!response?.callback?.isOk) F3.throw('local-manager-send-failed')
-
-            this.def.reportWorkers(`✅ local-manager-send-success`)
-
-            return true
-
-        } catch (e) { F3.catch.throw(e) }
-    }
-
-    run = async ({ payload, app, target }) => {
-
-        try {
-
-            if (!F3.obj.isGood(payload)) F3.throw('local-payload-not-valid')
-            if (!F3.obj.isGood(app)) F3.throw('local-app-not-valid')
-            if (!F3.str.isGood(target)) F3.throw('local-target-not-valid')
-
-            const { get, confirm, meta } = payload
-
-            if (!F3.str.isGood(get)) F3.throw('local-get-not-valid')
-            if (!F3.str.isGood(confirm)) F3.throw('local-confirm-not-valid')
-            if (!F3.str.isGood(meta)) F3.throw('local-meta-not-valid')
-
-            const responseGet = await axios.get(get, { responseType: 'arraybuffer' })
-
-            if (!responseGet?.data) F3.throw('local-download-not-valid')
-
-            const filePath = this.def.files.export.volumeZip
-
-            await fsa.writeFile(filePath, responseGet.data)
-
-            this.def.reportWorkers(`✅ local-zip-downloaded ${filePath}`)
-
-            const responseMeta = await axios.post(meta)
-
-            if (!F3.obj.isGood(responseMeta?.data)) F3.throw('local-meta-response-not-valid')
-            if (!F3.obj.isGood(responseMeta?.data?.plan)) F3.throw('local-meta-plan-not-valid')
-            if (!F3.obj.isGood(responseMeta?.data?.manifest)) F3.throw('local-meta-manifest-not-valid')
-
-            const { plan, manifest } = responseMeta.data
-
-            this.def.reportWorkers(`✅ local-meta-received`)
-
-            await this.send({ app, target, plan, manifest })
-
-            const responseConfirm = await axios.post(confirm)
-
-            if (!responseConfirm?.data?.isOk) F3.throw('local-confirm-not-valid')
-
-            this.def.reportWorkers(`✅ local-confirm-sent`)
-
-            return true
-
-        } catch (e) { F3.catch.throw(e) }
-    }
-}

package/assets/root.fullstackunicorn.dev/assets/modules/sync.tools.js

@@ -1,135 +0,0 @@
-import { fsa, crypto } from '#@/index.dep.js'
-
-export class Tools {
-
-    constructor(init) {
-
-        this.def = init.def
-
-    }
-
-    getManifestDate = () => {
-        const d = new Date()
-        const days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat']
-        const months = ['jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
-        const timestamp = d.getTime()
-        return `${timestamp}-${days[d.getDay()]}.${String(d.getDate()).padStart(2, '0')}.${months[d.getMonth()]}.${d.getFullYear()}-${String(d.getHours()).padStart(2, '0')}.${String(d.getMinutes()).padStart(2, '0')}`
-    }
-
-    getManifest = async (basePath = this.def.folders.volume, schema = 'manifest.raw.sync.request', filter = null) => {
-
-        try {
-
-            const manifest = {}
-            manifest.schema = schema
-            manifest.date = this.getManifestDate()
-            manifest.version = 1
-            manifest.total = 0
-            manifest.files = {}
-            await this.addFiles(basePath, '', manifest, filter)
-            await fsa.ensureFileDir(this.def.files.export.manifest)
-            await fsa.writeJSON(this.def.files.export.manifest, manifest)
-            return manifest
-
-        } catch (error) { F3.catch.throw(error, 'sync-client-getManifest-failed') }
-    }
-
-    getWorkspaceManifest = async () => {
-        return await this.getManifest(this.def.workspace, 'manifest.workspace.sync.request', relPath => this.isWorkspaceFile(relPath))
-    }
-
-    isWorkspaceFile = (relPath = '') => {
-
-        if (!F3.str.isGood(relPath)) return false
-
-        const root = relPath.split('/')[0]
-        if (!['config', 'volume'].includes(root)) return false
-
-        const reports = [
-            'local.workspace.md',
-            'local.assets.md',
-            'local.workers.md',
-            'sv1.workspace.md',
-            'sv1.assets.md',
-            'sv1.workers.md',
-            'stage.workspace.md',
-            'stage.assets.md',
-            'stage.workers.md',
-            'production.workspace.md',
-            'production.assets.md',
-            'production.workers.md'
-        ]
-
-        if (reports.includes(relPath)) return false
-
-        return true
-    }
-
-
-    addFiles = async (basePath, rel = '', manifest, filter = null) => {
-
-        const dir = rel ? `${basePath}/${rel}` : basePath
-        const entries = await fsa.readDir(dir)
-
-        for (const entry of entries) {
-
-            if (fsa.isJunk(entry)) continue
-
-            const nextRel = rel ? `${rel}/${entry}` : entry
-            const fullPath = `${basePath}/${nextRel}`
-            const stat = await fsa.stat(fullPath)
-
-            if (stat.isDirectory()) {
-                await this.addFiles(basePath, nextRel, manifest, filter)
-                continue
-            }
-
-            if (typeof filter === 'function' && !filter(nextRel)) continue
-
-            const buffer = await fsa.readFile(fullPath)
-            const hash = this.hash(buffer)
-            manifest.files[nextRel] = hash
-            manifest.total += 1
-        }
-    }
-
-    hash = (buffer) => {
-        const buf = buffer instanceof ArrayBuffer ? Buffer.from(buffer) : buffer
-        return crypto.createHash('sha256').update(buf).digest('hex')
-    }
-
-    getList = async basePath => {
-        const files = []
-        const scan = async dir => {
-            const entries = await fsa.readDir(dir)
-            for (const entry of entries) {
-                if (fsa.isJunk(entry)) continue
-                const fullPath = `${dir}/${entry}`
-                const stat = await fsa.stat(fullPath)
-                if (stat.isDirectory()) await scan(fullPath)
-                else files.push(fullPath.replace(`${basePath}/`, ''))
-            }
-        }
-        await scan(basePath)
-        return files
-    }
-
-    pathToObj = (obj, path, val) => {
-
-        if (!path) return
-
-        const keys = path.split('/')
-        const parents = keys.slice(0, -1)
-        const last = keys[keys.length - 1]
-
-        let ref = obj
-
-        for (const key of parents) {
-            if (!F3.isObj(ref[key])) ref[key] = {}
-            ref = ref[key]
-        }
-
-        ref[last] = val
-    }
-
-}

package/assets/root.fullstackunicorn.dev/assets/package.json

@@ -1,32 +0,0 @@
-{
-    "name": "@root.fullstackunicorn.dev/assets",
-    "author": "lucanigido (https://fullstackunicorn.dev/author/lucanigido)",
-    "version": "1.0.0",
-    "type": "module",
-    "license": "UNLICENSED",
-    "private": true,
-    "imports": {
-        "#@": "./",
-        "#@/*": "./*"
-    },
-    "scripts": {
-        "initialize": "chmod +x ./config.cmd.sh && bash ./config.cmd.sh add",
-        "cmd": "chmod +x ./config.cmd.sh && env-cmd -f .env bash ./config.cmd.sh",
-        "test": "exit 1"
-    },
-    "dependencies": {
-        "@fullstackunicorn/filesystem": "^1.0.16",
-        "@fullstackunicorn/initialize": "^1.0.15",
-        "@fullstackunicorn/upload": "^1.0.11",
-        "@fullstackunicorn/websites": "^1.0.10",
-        "axios": "^1.15.0",
-        "blurhash": "^2.0.5",
-        "jszip": "^3.10.1",
-        "sharp": "^0.34.5"
-    },
-    "devDependencies": {
-        "@fullstackunicorn/cli": "^1.0.8",
-        "env-cmd": "^11.0.0",
-        "nodemon": "^3.1.14"
-    }
-}

package/assets/root.fullstackunicorn.dev/assets/package.md

@@ -1,29 +0,0 @@
-Create-root local flow:
-
-```bash
-yarn cmd website local-push
-yarn cmd website local-assets
-yarn cmd website local-workers
-```
-
-Other supported commands:
-
-```bash
-yarn cmd website workspace-cleanup
-yarn cmd website develop-cleanup
-
-yarn cmd website local-config
-yarn cmd website local-pull
-
-yarn cmd website sv1-config
-yarn cmd website sv1-push
-yarn cmd website sv1-pull
-yarn cmd website sv1-assets
-yarn cmd website sv1-workers
-
-yarn cmd website stage-config
-yarn cmd website stage-push
-yarn cmd website stage-pull
-yarn cmd website stage-assets
-yarn cmd website stage-workers
-```