@fullstackunicorn/create-root 1.0.17 → 1.0.19

package/assets/root.fullstackunicorn.dev/frontend/vite.sworker.js

@@ -0,0 +1,56 @@
+import fs from 'fs'
+import path from 'path'
+import crypto from 'crypto'
+
+class SworkerPlugin {
+
+    constructor () {
+
+        this.ctx = {}
+        this.ctx.name = 'serviceworker'
+        this.ctx.workerSource = path.resolve('sworker/sw.js')
+        this.ctx.versionFile = 'serviceworker.version.json'
+        this.ctx.workerFile = 'serviceworker.js'
+    }
+
+    isBuild = mode => mode === 'production'
+
+    generateVersion = () => {
+        return crypto.randomBytes(8).toString('hex')
+    }
+
+    writeVersionFile = (dir) => {
+        const version = this.generateVersion()
+        const filePath = path.join(dir, this.ctx.versionFile)
+        fs.writeFileSync(
+            filePath,
+            JSON.stringify({ version }, null, 2),
+            'utf-8'
+        )
+    }
+
+    copyWorkerFile = (dir) => {
+        const dest = path.join(dir, this.ctx.workerFile)
+        fs.copyFileSync(this.ctx.workerSource, dest)
+    }
+
+    onWriteBundle = ({ dir }) => {
+        this.writeVersionFile(dir)
+        this.copyWorkerFile(dir)
+    }
+
+    build = () => {
+
+        const plugin = {}
+        plugin.name = this.ctx.name
+        plugin.apply = 'build'
+        plugin.writeBundle = this.onWriteBundle
+
+        return plugin
+    }
+}
+
+export function sworkerPlugin () {
+    const sw = new SworkerPlugin()
+    return sw.build()
+}

package/assets/root.fullstackunicorn.dev/frontend/vite.volume.js

@@ -0,0 +1,94 @@
+import fs from 'fs'
+import path from 'path'
+import mime from 'mime-types'
+
+class VolumePlugin {
+
+    constructor() {
+        this.ctx = {}
+        this.ctx.name = 'volume'
+        this.ctx.appRoot = path.resolve('../volume')
+
+        this.ctx.map = [
+            ['/get', 'get'],
+            ['/fonts', 'fonts'],
+            ['/sitemap', 'sitemap'],
+            ['/statics', 'statics'],
+        ]
+
+        // routes under /get that auto-append .json
+        this.ctx.jsonRoutes = [
+            '/data'
+        ]
+    }
+
+    isDev = mode => mode === 'development'
+
+    getRel = req => decodeURIComponent((req.url || '').split('?')[0] || '/')
+
+    isForbidden = (file, folder) => !file.startsWith(folder)
+
+    canStream = file => fs.existsSync(file) && !fs.statSync(file).isDirectory()
+
+    streamFile = (res, file) => fs.createReadStream(file).pipe(res)
+
+    shouldForceJson = (rel, file) => {
+        if (path.extname(file)) return false
+        return this.ctx.jsonRoutes.some(route => rel.startsWith(route))
+    }
+
+    middleware = (folder) => {
+        return (req, res, next) => {
+
+            const rel = this.getRel(req)
+            let file = path.join(folder, rel)
+
+            if (this.shouldForceJson(rel, file)) {
+                file = `${file}.json`
+            }
+
+            if (this.isForbidden(file, folder)) {
+                res.statusCode = 403
+                return res.end('forbidden')
+            }
+
+            if (!this.canStream(file)) return next()
+
+            // content-type
+            if (file.endsWith('.json')) {
+                res.setHeader('Content-Type', 'application/json; charset=utf-8')
+            } else {
+                const type = mime.lookup(file)
+                if (type) {
+                    res.setHeader('Content-Type', type)
+                }
+            }
+
+            return this.streamFile(res, file)
+        }
+    }
+
+    mount = (server) => {
+        for (const [urlBase, folderName] of this.ctx.map) {
+            const folder = path.join(this.ctx.appRoot, folderName)
+            server.middlewares.use(urlBase, this.middleware(folder))
+        }
+    }
+
+    build = (mode) => {
+
+        if (!this.isDev(mode)) return null
+
+        const plugin = {}
+        plugin.name = this.ctx.name
+        plugin.apply = 'serve'
+        plugin.configureServer = this.mount
+
+        return plugin
+    }
+}
+
+export function volumePlugin(mode) {
+    const volume = new VolumePlugin()
+    return volume.build(mode)
+}

package/assets/root.fullstackunicorn.dev/manager/.env

@@ -0,0 +1,10 @@
+SERVER_TYPE="cms"
+SERVER_NAME="cms.root.fullstackunicorn.dev"
+SERVER_PORT="9002"
+
+CLIENT_ID="58cd62f9-cb56-46c8-9d37-140bf3fa7f31"
+
+AUTH_CLIENT="root.fullstackunicorn.dev"
+AUTH_URL_CERTIFICATE="https://api.auth.minderable.com/certificate"
+AUTH_URL_VERIFY="https://api.auth.minderable.com/verify"
+AUTH_URL_ISSUER="https://auth.loginner.com/realms/Minderable"

package/assets/root.fullstackunicorn.dev/manager/config.cmd.sh

@@ -0,0 +1,81 @@
+#!/bin/bash
+set -e
+# ============================================================
+add() {
+
+    echo "🚀 [manager] Adding Dependencies"
+
+        yarn add @fullstackunicorn/auth --latest
+        yarn add @fullstackunicorn/filesystem --latest
+        yarn add @fullstackunicorn/initialize --latest
+        yarn add @fullstackunicorn/upload --latest
+
+        yarn add cors --latest
+        yarn add express --latest
+        yarn add express-fileupload --latest
+        
+        yarn add jszip --latest
+        yarn add uuid --latest
+
+    echo "🚀 [manager] Adding Dev Dependencies"
+
+        yarn add -D env-cmd --latest
+        yarn add -D nodemon --latest
+
+    echo "✅ [manager] Dependencies added!"
+}
+# ============================================================
+upgrade() {
+
+    echo "🚀 [manager] Upgrading Dependencies"
+
+        yarn upgrade @fullstackunicorn/auth --latest
+        yarn upgrade @fullstackunicorn/filesystem --latest
+        yarn upgrade @fullstackunicorn/initialize --latest
+        yarn upgrade @fullstackunicorn/upload --latest
+
+    echo "✅ [manager] Upgaded!"
+}
+# ============================================================
+remove() {
+
+    echo "🧹 [manager] Removing Dependencies"
+
+        node --input-type=module -e "
+            import fs from 'fs'
+            const filePath = './package.json'
+            const json = JSON.parse(fs.readFileSync(filePath, 'utf8'))
+            json.dependencies = {}
+            json.devDependencies = {}
+            fs.writeFileSync(filePath, JSON.stringify(json, null, 4))
+        "
+
+    echo "✅ [manager] Dependeincies Removed!"
+}
+# ============================================================
+initialize() {
+
+    echo "🚀 [manager] Initialize"
+
+    remove
+    add
+
+    echo "✅ [manager] Initialized!"
+
+}
+# ============================================================
+info() {
+    echo "❌ Unknown command: $1"
+    echo "Available commands:"
+    declare -F | awk '{print "  " $3}' | grep -v "^info$"
+    exit 1
+}
+# ============================================================
+cmd="${1:-}"
+shift || true
+if declare -F "$cmd" >/dev/null && [[ "$cmd" != "info" ]]; then
+    "$cmd" "$@"
+else
+    info "$cmd"
+fi
+# ============================================================

package/assets/root.fullstackunicorn.dev/manager/dockerfile

@@ -0,0 +1,12 @@
+FROM node:20-alpine
+
+WORKDIR /app
+
+COPY package.json yarn.lock ./
+COPY . .
+
+RUN yarn install --production
+
+ENTRYPOINT [ "yarn" ]
+
+CMD [ "run", "start:prod" ]

package/assets/root.fullstackunicorn.dev/manager/index.def.js

@@ -0,0 +1,17 @@
+export class Def {
+
+    constructor() {
+
+        this.cwd = process.cwd()
+
+        this.folders = {}
+        this.folders.completed = `${this.cwd}/private/completed`
+        this.folders.publications = `${this.cwd}/private/publications`
+        this.folders.volume = `${this.cwd}/volume`
+
+        this.files = {}
+        this.files.manifest = `${this.folders.publications}/manifest.json`
+        
+    }
+
+}

package/assets/root.fullstackunicorn.dev/manager/index.dep.js

@@ -0,0 +1,17 @@
+// @FULLSTACKUNICORN
+// export { auth } from '@fullstackunicorn/auth'
+export { fsa, fss } from '@fullstackunicorn/filesystem'
+export { Receiver } from '@fullstackunicorn/upload'
+
+// NODE
+export { fileURLToPath as getUrl } from 'url'
+export { default as path } from 'path'
+
+// SERVER
+export { default as cors} from 'cors'
+export { default as express, Router } from 'express'
+export { default as fileUpload } from 'express-fileupload'
+
+// TOOLS 
+export { default as JSZip } from 'jszip'
+export { v4 as makeId } from 'uuid' 

package/assets/root.fullstackunicorn.dev/manager/index.init.js

@@ -0,0 +1,38 @@
+import { path, fss } from '#@/index.dep.js'
+
+const init = {}
+
+init.service = () => {
+    F3.service = `manager:${process.env.SERVER_NAME}`
+    F3.logs('[🦄] F3.service: ', F3.service)
+}
+
+init.basePath = () => process.env.BASE_PATH = process.cwd()
+
+init.fileUpload = () => {
+    const tempFileDir = path.resolve('private/temp')
+    fss.ensureDir(tempFileDir)
+    return {
+        useTempFiles: true,
+        tempFileDir,
+        createParentPath: true,
+        limits: { fileSize: 2 * 1024 * 1024 * 1024 }
+    }
+}
+
+init.corsOptions = () => {
+    const { CORS_ORIGIN } = process.env
+    return {
+        origin: `${CORS_ORIGIN || "*"}`,
+        optionsSuccessStatus: 200
+    }
+}
+
+init.server = () => {
+    const { SERVER_NAME, SERVER_PORT, BASE_PATH } = process.env
+    F3.logs(`${SERVER_NAME} Server Listening on Port ${SERVER_PORT}`)
+    F3.logs(`${SERVER_NAME} Server Base Path ${BASE_PATH}`)
+    F3.logs(`\n`)
+}
+
+export { init }

package/assets/root.fullstackunicorn.dev/manager/index.js

@@ -0,0 +1,17 @@
+import '@fullstackunicorn/initialize'
+import { init } from '#@/index.init.js'
+import { express, cors, fileUpload } from '#@/index.dep.js'
+import { router } from '#@/server/router.js'
+
+init.service()
+
+init.basePath()
+
+const app = express()
+app.use(express.json({ limit: '30mb' }))
+app.use(cors(init.corsOptions()))
+app.use(fileUpload(init.fileUpload()))
+
+app.use(router)
+
+app.listen(process.env.SERVER_PORT, init.server)

package/assets/root.fullstackunicorn.dev/manager/modules/clone.js

@@ -0,0 +1,65 @@
+import { fsa } from '#@/index.dep.js'
+
+class Clone {
+
+    constructor() {
+
+        this.validPaths = {
+            stage: 'volume',
+            sv1: 'volumesv1',
+            prod: 'volumeprod'
+        }
+
+    }
+
+    isStageDeploy = async () => {
+
+        try {
+
+            const validPaths = Object.values(this.validPaths)
+
+            let stage = true
+            for (let path of validPaths) {
+                const check = await fsa.isDir(path)
+                stage = check === false ? false : stage
+            }
+
+            if (!stage) F3.throw("not-on-stage")
+            return true
+
+        } catch (e) { F3.catch.throw(e, 'Clone.clone') }
+    }
+
+    checkPathTags = async (pathTags = []) => {
+
+        try {
+
+            await this.isStageDeploy()
+            const validPathTags = Object.keys(this.validPaths)
+
+            for (let pathTag of pathTags) {
+                if (!validPathTags.includes(pathTag)) F3.throw("Source/Destination Path not valid")
+            }
+
+            return true
+
+        } catch (e) { F3.catch.throw(e, 'Clone.clone') }
+
+    }
+
+    run = async (request) => {
+
+        const { params } = request
+        const { source, destination } = params
+
+        try {
+
+            await this.checkPathTags([source, destination])
+            await fsa.syncDirSafe(this.validPaths[source], this.validPaths[destination])
+            return true
+
+        } catch (e) { F3.catch.throw(e, 'Clone.clone') }
+    }
+}
+
+export const clone = new Clone()

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

@@ -0,0 +1,65 @@
+import { fsa, Receiver } from '#@/index.dep.js'
+import { Tools } from '#@/modules/sync.tools.js'
+import { Workspace } from '#@/modules/workspace.js'
+import { Def } from '#@/index.def.js'
+
+class Sync {
+
+    constructor() {
+
+        this.ctx = {}
+        this.def = new Def()
+
+        this.tools = new Tools({def:this.def})
+
+        this.receiver = new Receiver({
+            tmp: this.def.folders.completed,
+            onCompleted: this.onCompleted
+        })
+    }
+
+    status = async (request) => await this.receiver.handleStatus(request)
+    file = async (request) => await this.receiver.handleFile(request)
+    chunk = async (request) => await this.receiver.handleChunk(request)
+    finalize = async (request) => await this.receiver.handleFinalize(request)
+
+    onCompleted = async ({ filePath, fileId, target, payload = {} }) => {
+
+        const { plan, manifest } = payload
+
+        this.ctx = {}
+        this.ctx.zip = {}
+        this.ctx.zip.path = filePath
+        this.ctx.zip.id = fileId
+        this.ctx.target = target
+        this.ctx.plan = plan
+        this.ctx.manifest = manifest
+        
+        const { ctx, def } = this
+        const workspace = new Workspace({ ctx, def })
+        return await workspace.run()
+    }
+
+    current = async (request) => {
+
+        try {
+
+            if (!F3.obj.isGood(request?.body)) F3.throw('invalid-body')
+
+            const { clientId, importId } = request?.body
+            // controlla clientId
+
+            const current = await fsa.readJSON(this.def.files.manifest)
+            if (F3.obj.isGood(current)) return current
+            
+            const manifest = this.tools.getNewManifest()
+            return manifest
+
+        } catch (error) { F3.catch.throw(error, 'sync-plan-failed')}
+    }
+
+
+
+}
+
+export const sync = new Sync()

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

@@ -0,0 +1,55 @@
+import { fsa } 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')}`
+    }
+
+    getNewManifest = async () => {
+
+        try {
+
+            const manifest = {}
+            manifest.schema = 'manifest.sync.request'
+            manifest.date = this.getManifestDate()
+            manifest.version = 1
+            manifest.total = 0
+            manifest.files = {}
+            await fsa.ensureFileDir(this.def.files.manifest)
+            await fsa.writeJSON(this.def.files.manifest, manifest)
+            return manifest
+
+        } catch (error) { F3.catch.throw(error, 'Tools.getNewManifest-failed') }
+    }
+
+    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/manager/modules/workspace.js

@@ -0,0 +1,77 @@
+import { fsa, JSZip } from '#@/index.dep.js'
+import { Tools } from '#@/modules/workspace.tools.js'
+
+export class Workspace {
+
+    constructor(init) {
+
+        this.ctx = init.ctx
+        this.def = init.def
+
+        this.report = {}
+        this.report.isOk = false
+        this.report.written = []
+        this.report.deleted = []
+
+        const { report, ctx, def } = this
+        this.tools = new Tools({ report, ctx, def })
+    }
+
+    run = async () => {
+        try {
+            await this.unzip()
+            await this.normalize()
+            this.report.isOk = true
+            return this.report
+        } catch (error) { F3.catch.throw(error, 'Workspace.run-failed') }
+    }
+
+    unzip = async () => {
+
+        try {
+
+            const zipBuffer = await fsa.readFile(this.ctx.zip.path)
+
+            const zip = await JSZip.loadAsync(zipBuffer)
+            await fsa.ensureDir(this.def.folders.volume)
+
+            for (const name of Object.keys(zip.files)) {
+                const entry = zip.files[name]
+                if (entry.dir) continue
+                const filePath = `${this.def.folders.volume}/${name}`
+                const buffer = await entry.async('nodebuffer')
+                await fsa.ensureFileDir(filePath)
+                await fsa.writeFile(filePath, buffer)
+                this.report.written.push(name)
+            }
+
+            await fsa.ensureFileDir(this.def.files.manifest)
+            await fsa.writeJSON(this.def.files.manifest, this.ctx.manifest)
+
+        } catch (error) { F3.catch.throw(error, 'Workspace.unzip-failed') }
+
+    }
+
+    normalize = async () => {
+
+        try {
+
+            const manifest = await fsa.readJSON(this.def.files.manifest)
+            const manifestPaths = new Set(Object.keys(manifest.files || {}))
+
+            const allFiles = await this.tools.getList(this.def.folders.volume)
+
+            for (const relPath of allFiles) {
+                if (!manifestPaths.has(relPath)) {
+                    await fsa.safeRemove(`${this.def.folders.volume}/${relPath}`)
+                    this.report.deleted.push(relPath)
+                }
+            }
+
+            await this.tools.removeEmptyDirs(this.def.folders.volume)
+
+        } catch (error) { F3.catch.throw(error, 'Workspace.normalize-failed') }
+    }
+
+}
+

package/assets/root.fullstackunicorn.dev/manager/modules/workspace.tools.js

@@ -0,0 +1,49 @@
+import { path, fsa } from '#@/index.dep.js'
+
+export class Tools {
+
+    constructor(init) {
+
+        this.def = init.def
+        this.report = init.report
+
+    }
+
+    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
+    }
+
+    removeEmptyDirs = async (dir) => {
+
+        const entries = await fsa.readDir(dir)
+
+        for (const entry of entries) {
+
+            const full = `${dir}/${entry}`
+            const stat = await fsa.stat(full)
+
+            if (!stat.isDirectory()) continue
+
+            await this.removeEmptyDirs(full)
+            const sub = await fsa.readDir(full)
+
+            if (sub.length === 0) {
+                const rel = path.relative(this.def.folders.volume, full)
+                await fsa.safeRemove(full)
+                this.report.deleted.push(rel)
+            }
+        }
+    }
+}