@fullstackunicorn/create-root 1.0.17 → 1.0.19

package/assets/root.fullstackunicorn.dev/backend/modules/stripe.js

@@ -0,0 +1,299 @@
+import { StripeSdk, jwtEncode, fsa } from '#@/index.dep.js'
+import { Def } from '#@/index.def.js'
+import { Tools } from '#@/modules/stripe.tools.js'
+
+export class Stripe {
+
+    constructor() {
+
+        this.def = new Def()
+        this.tools = new Tools()
+        this.client = new StripeSdk(process.env.STRIPE_SECRET_KEY)
+
+        this.url = {}
+        this.url.pay = `https://${process.env.CLIENT_URL}/pay`
+
+        this.secret = {}
+        this.secret.checkout = process.env.CHECKOUT_TOKEN_SECRET
+    }
+
+    getToken = (payload = {}) => {
+        try {
+            return jwtEncode(payload, this.secret.checkout)
+        } catch (e) { F3.catch.throw(e, 'Stripe.getToken-failed') }
+    }
+
+    getPayUrl = ({ status, product, seller }) => {
+
+        const payload = {}
+        payload.type = 'checkout'
+        payload.status = status
+        payload.product = product
+        payload.seller = seller
+
+        const token = this.getToken(payload)
+
+        return `${this.url.pay}?token=${encodeURIComponent(token)}`
+    }
+
+    getClientReferenceId = ({ product, seller }) => {
+        return `${seller.code || 'noseller'}__${product.code}__${product.lang}`
+    }
+
+    getMetadata = ({ product, seller }) => {
+
+        const metadata = {}
+
+        metadata.product_code = product.code
+        metadata.product_path = product.path
+        metadata.product_lang = product.lang
+        metadata.fulfillment_key = `${product.code}__${product.lang}`
+        metadata.product_name = product.name
+        metadata.seller_code = seller.code || ''
+        metadata.seller_name = seller.name || ''
+
+        return metadata
+    }
+
+    getSeller = () => {
+
+        const seller = {}
+        seller.code = 'home'
+        seller.name = 'home'
+
+        return seller
+    }
+
+    getCheckoutBody = (request = {}) => {
+
+        const body = request?.body
+        if (!F3.isObj(body)) F3.throw('checkout-request-invalid')
+
+        const response = {}
+        response.lang = body?.lang
+        response.code = body?.code
+        response.currency = body?.currency
+        response.price = body?.price
+        response.quantity = Number(body?.quantity)
+
+        if (!F3.str.isGood(response.lang)) F3.throw('checkout-request-invalid')
+        if (!F3.str.isGood(response.code)) F3.throw('checkout-product-invalid')
+        if (!F3.str.isGood(response.currency)) F3.throw('checkout-currency-invalid')
+        if (!F3.isNum(response.quantity) || response.quantity <= 0) F3.throw('checkout-request-invalid')
+        if (!F3.str.isGood(String(response.price || '')) && !F3.isNum(response.price)) F3.throw('checkout-price-invalid')
+
+        return response
+    }
+
+    getCheckoutBase = code => `/get/data/modules/checkout/${code}`
+
+    getVolumeJson = async url => {
+
+        const filePath = `${this.def.volume}${url}.json`
+
+        try {
+            const data = await fsa.readJSON(filePath)
+            if (!F3.obj.isGood(data)) F3.throw('checkout-product-invalid', { url })
+            return data
+        } catch {
+            F3.throw('checkout-product-invalid', { url, filePath })
+        }
+    }
+
+    getCheckoutFiles = async ({ lang, code }) => {
+
+        const base = this.getCheckoutBase(code)
+
+        const verbal = await this.getVolumeJson(`${base}/${lang}`)
+        const logic = await this.getVolumeJson(`${base}/@logic`)
+
+        return { verbal, logic }
+    }
+
+    getServerPrice = ({ logic = {}, currency = '' }) => {
+
+        const item = logic?.['@data']?.price?.[currency]
+        if (!F3.obj.isGood(item)) F3.throw('checkout-currency-invalid', { currency })
+
+        return item?.price?.value
+    }
+
+    verifyClientPrice = ({ input = {}, serverPrice }) => {
+
+        const clientPrice = this.tools.getComparablePrice(input.price)
+        const verifiedServerPrice = this.tools.getComparablePrice(serverPrice)
+
+        if (clientPrice === verifiedServerPrice) return
+
+        F3.logs({
+            type: 'checkout-price-mismatch',
+            code: input.code,
+            lang: input.lang,
+            currency: input.currency,
+            clientPrice,
+            serverPrice: verifiedServerPrice
+        })
+
+        F3.throw('checkout-price-invalid')
+    }
+
+    getStripeProduct = async ({ input = {}, verbal = {}, logic = {} }) => {
+
+        const item = verbal?.['@data']?.product?.item || {}
+        const serverPrice = this.getServerPrice({ logic, currency: input.currency })
+
+        this.verifyClientPrice({ input, serverPrice })
+
+        const product = {}
+        product.code = item.code
+        product.path = item.path
+        product.lang = input.lang
+        product.name = item.title
+        product.description = item.description
+        product.image = await this.tools.getImageUrl(item.image)
+        product.price = this.tools.getStripeAmount({ value: serverPrice, currency: input.currency })
+        product.currency = input.currency
+        product.quantity = input.quantity
+
+        if (!F3.str.isGood(product.code)) F3.throw('checkout-product-invalid')
+        if (!F3.str.isGood(product.path)) F3.throw('checkout-product-invalid')
+        if (!F3.str.isGood(product.name)) F3.throw('checkout-product-invalid')
+        if (!F3.str.isGood(product.description)) F3.throw('checkout-product-invalid')
+        if (!F3.str.isGood(product.image)) F3.throw('checkout-product-invalid')
+
+        return product
+    }
+
+    getStripeSessionInput = ({ product, seller }) => {
+
+        const client_reference_id = this.getClientReferenceId({ product, seller })
+        const metadata = this.getMetadata({ product, seller })
+        const success_url = this.getPayUrl({ status: 'success', product, seller })
+        const cancel_url = this.getPayUrl({ status: 'cancel', product, seller })
+        const payment_intent_data = { metadata }
+
+        return {
+            mode: 'payment',
+            client_reference_id,
+            success_url,
+            cancel_url,
+            metadata,
+            payment_intent_data,
+            line_items: [
+                {
+                    quantity: product.quantity,
+                    price_data: {
+                        currency: product.currency,
+                        unit_amount: product.price,
+                        product_data: {
+                            name: product.name,
+                            description: product.description,
+                            images: [product.image],
+                            metadata: {
+                                product_code: product.code,
+                                product_path: product.path,
+                                product_lang: product.lang
+                            }
+                        }
+                    }
+                }
+            ],
+            shipping_address_collection: {
+                allowed_countries: ['IT', 'IE', 'GB']
+            },
+            shipping_options: [
+                {
+                    shipping_rate_data: {
+                        type: 'fixed_amount',
+                        fixed_amount: {
+                            amount: 0,
+                            currency: product.currency
+                        },
+                        display_name: 'Free shipping'
+                    }
+                }
+            ],
+        }
+    }
+
+    verifyGet = (request = {}) => {
+
+        const session_id = request?.body?.session_id
+        if (!F3.str.isGood(session_id)) F3.throw('missing-session-id')
+
+        return { session_id }
+    }
+
+    handleStripeError = error => {
+
+        const code = error?.code || ''
+        const type = error?.type || ''
+
+        if (code === 'parameter_invalid_integer') F3.throw('invalid-product-price')
+        if (code === 'parameter_invalid_empty') F3.throw('checkout-product-invalid')
+        if (code === 'resource_missing') F3.throw('missing-session')
+        if (code === 'url_invalid') F3.throw('checkout-url-invalid')
+        if (code === 'amount_too_small') F3.throw('checkout-price-invalid')
+        if (code === 'amount_too_large') F3.throw('checkout-price-invalid')
+        if (code === 'currency_not_supported') F3.throw('checkout-currency-invalid')
+
+        if (type === 'StripeAuthenticationError') F3.throw('checkout-provider-invalid')
+        if (type === 'StripePermissionError') F3.throw('checkout-provider-forbidden')
+        if (type === 'StripeConnectionError') F3.throw('checkout-provider-unavailable')
+        if (type === 'StripeAPIError') F3.throw('checkout-provider-error')
+        if (type === 'StripeInvalidRequestError') F3.throw('checkout-request-invalid')
+
+        throw error
+    }
+
+    set = async request => {
+
+        try {
+
+            const input = this.getCheckoutBody(request)
+            const seller = this.getSeller()
+            const { verbal, logic } = await this.getCheckoutFiles(input)
+            const product = await this.getStripeProduct({ input, verbal, logic })
+            const payload = this.getStripeSessionInput({ product, seller })
+
+            const session = await this.client.checkout.sessions.create(payload)
+
+            if (!F3.str.isGood(session?.url)) F3.throw('missing-session-url')
+            if (!F3.str.isGood(session?.id)) F3.throw('missing-session-id')
+
+            return { isValid: true, id: session.id, url: session.url }
+
+        } catch (e) {
+            F3.logs(e)
+            try { this.handleStripeError(e) }
+            catch (error) { F3.catch.throw(error, 'Stripe.set-failed') }
+        }
+    }
+
+    get = async request => {
+
+        try {
+
+            const { session_id } = this.verifyGet(request)
+
+            const session = await this.client.checkout.sessions.retrieve(session_id)
+
+            if (!session?.id) F3.throw('missing-session')
+
+            return {
+                isValid: true,
+                id: session.id,
+                status: session.status,
+                payment_status: session.payment_status,
+                client_reference_id: session.client_reference_id,
+                metadata: session.metadata || {}
+            }
+
+        } catch (e) {
+            F3.logs(e)
+            try { this.handleStripeError(e) }
+            catch (error) { F3.catch.throw(error, 'Stripe.get-failed') }
+        }
+    }
+
+}

package/assets/root.fullstackunicorn.dev/backend/modules/stripe.session.js

@@ -0,0 +1 @@
+

package/assets/root.fullstackunicorn.dev/backend/modules/stripe.tools.js

@@ -0,0 +1,126 @@
+import { fsa } from '#@/index.dep.js'
+import { Def } from '#@/index.def.js'
+
+export class Tools {
+
+    constructor() {
+
+        this.def = new Def()
+        this.imageBaseUrl = `https://${process.env.CLIENT_URL}`
+
+        this.currencyDecimals = {}
+        this.currencyDecimals.EUR = 2
+        this.currencyDecimals.DKK = 2
+        this.currencyDecimals.CZK = 2
+        this.currencyDecimals.CHF = 2
+        this.currencyDecimals.USD = 2
+        this.currencyDecimals.HUF = 2
+
+        this.widths = {}
+        this.widths.TS = 64
+        this.widths.TM = 256
+        this.widths.TL = 512
+        this.widths.SD = 960
+        this.widths.MD = 1440
+        this.widths.HD = 1920
+    }
+
+    getMediaMetaPath = (src = '') => {
+
+        if (!F3.str.isGood(src)) F3.throw('checkout-product-invalid', { src })
+
+        const normalized = src
+            .replace(/^\/+/, '')
+            .replace(/\/(TS|TM|TL|SD|MD|HD)\//, '/')
+
+        return normalized
+            .replace(/\.[^.]+$/, '.json')
+    }
+
+    getMediaVariant = max => {
+
+        const current = this.widths?.[max]
+        const target = this.widths.TL
+
+        if (!F3.isNum(current) || current <= 0) return 'TS'
+        if (current >= target) return 'TL'
+        return max
+    }
+
+    getMediaVariantPath = ({ src = '', variant = 'TS' }) => {
+        return src
+            .replace(/^\/+/, '')
+            .replace(/\/(TS|TM|TL|SD|MD|HD)\//, `/${variant}/`)
+    }
+
+    getImageUrl = async (image = {}) => {
+
+        const src = F3.isStr(image) ? image : (image?.src || '')
+        if (!F3.str.isGood(src)) F3.throw('checkout-product-invalid', { image })
+
+        const metaPath = this.getMediaMetaPath(src)
+        const filePath = `${this.def.volume}/get/media/${metaPath}`
+
+        let meta = {}
+
+        try {
+            meta = await fsa.readJSON(filePath)
+        } catch {
+            F3.throw('checkout-product-invalid', { image, filePath })
+        }
+
+        const variant = this.getMediaVariant(meta?.max)
+        const nextPath = this.getMediaVariantPath({ src, variant })
+
+        return `${this.imageBaseUrl}/get/media/${nextPath}`
+    }
+
+    getCurrencyDecimals = currency => {
+
+        const decimals = this.currencyDecimals?.[currency]
+        if (!F3.isNum(decimals) || decimals < 0) F3.throw('checkout-currency-invalid', { currency })
+
+        return decimals
+    }
+
+    getComparablePrice = value => {
+
+        const text = String(value ?? '').trim()
+        if (!F3.str.isGood(text)) F3.throw('checkout-price-invalid', { value })
+
+        return text.replace(/\s+/g, '')
+    }
+
+    normalizeDecimalSeparator = value => {
+
+        const text = this.getComparablePrice(value)
+
+        if (text.includes(',') && text.includes('.')) {
+            return text.replace(/\./g, '').replace(',', '.')
+        }
+
+        if (text.includes(',')) return text.replace(',', '.')
+        return text
+    }
+
+    getStripeAmount = ({ value, currency }) => {
+
+        const decimals = this.getCurrencyDecimals(currency)
+        const normalized = this.normalizeDecimalSeparator(value)
+        const amount = Number(normalized)
+
+        if (!F3.isNum(amount) || amount <= 0) F3.throw('checkout-price-invalid', { value, currency, normalized })
+
+        const multiplier = 10 ** decimals
+        const stripeAmount = Math.round(amount * multiplier)
+
+        if (!F3.isNum(stripeAmount) || stripeAmount <= 0) F3.throw('checkout-price-invalid', {
+            value,
+            currency,
+            normalized,
+            decimals
+        })
+
+        return stripeAmount
+    }
+}

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

@@ -0,0 +1,35 @@
+{
+    "name": "@root.fullstackunicorn.dev/backend",
+    "author": "lucanigido (https://fullstackunicorn.dev/author/lucanigido)",
+    "version": "1.0.0",
+    "type": "module",
+    "license": "UNLICENSED",
+    "private": true,
+    "main": "index.js",
+    "imports": {
+        "#@": "./",
+        "#@/*": "./*"
+    },
+    "scripts": {
+        "initialize": "chmod +x ./config.cmd.sh && bash ./config.cmd.sh add",
+        "cmd": "chmod +x ./config.cmd.sh && ./config.cmd.sh",
+        "start": "env-cmd -f .env node index.js",
+        "start:nodemon": "env-cmd -f .env nodemon --ignore ./volume/ --ignore ./private/ --trace-warnings -L index.js",
+        "start:prod": "NODE_ENV=production node index.js"
+    },
+    "dependencies": {
+        "@fullstackunicorn/auth": "^1.0.1",
+        "@fullstackunicorn/filesystem": "^1.0.16",
+        "@fullstackunicorn/initialize": "^1.0.15",
+        "axios": "^1.15.0",
+        "cors": "^2.8.6",
+        "express": "^5.2.1",
+        "jwt-decode": "^4.0.0",
+        "jwt-encode": "^1.0.1",
+        "stripe": "^22.0.2"
+    },
+    "devDependencies": {
+        "env-cmd": "^11.0.0",
+        "nodemon": "^3.1.14"
+    }
+}

package/assets/root.fullstackunicorn.dev/backend/server/errors.js

@@ -0,0 +1,29 @@
+import { list } from '#@/server/errors.list.js'
+
+class Errors {
+
+    error = {
+        send: { error: 'server-error' },
+        status: 400
+    }
+
+    getClientError = ({ service, message, params }) => {
+        const error = list?.[service]?.[message]
+        if (!F3.obj.isGood(error)) return this.error
+        const response = {}
+        response.status = error.status
+        response.send = {}
+        response.send.error = error.error
+        if (error.isParams) response.send.params = params
+        return response
+    }
+
+    returns = (response, path, error) => {
+        const { service, message, params } = error
+        const { status, send } = this.getClientError(error)
+        F3.logs('ERROR:', service, path, message, params, status, send)
+        return response.status(status).send(send)
+    }
+
+}
+export const errors = new Errors()

package/assets/root.fullstackunicorn.dev/backend/server/errors.list.js

@@ -0,0 +1,69 @@
+export const list = {
+    [F3.service]: {
+        'server-error': {
+            'isParams': false,
+            'error': 'server-error',
+            'status': 400,
+        },
+        'not-admitted-user': {
+            'isParams': false,
+            'error': `not-admitted-user`,
+            'status': 401
+        },
+        'not-authenticated': {
+            'isParams': false,
+            'error': 'not-authenticated',
+            'status': 401,
+        },
+        'already-admitted-user': {
+            'isParams': false,
+            'error': `already-admitted-user`,
+            'status': 401,
+        },
+        'checkout-product-invalid': {
+            isParams: false,
+            error: 'checkout-product-invalid',
+            status: 400
+        },
+        'checkout-url-invalid': {
+            isParams: false,
+            error: 'checkout-url-invalid',
+            status: 400
+        },
+        'checkout-provider-invalid': {
+            isParams: false,
+            error: 'checkout-provider-invalid',
+            status: 400
+        },
+        'checkout-provider-forbidden': {
+            isParams: false,
+            error: 'checkout-provider-forbidden',
+            status: 400
+        },
+        'checkout-provider-unavailable': {
+            isParams: false,
+            error: 'checkout-provider-unavailable',
+            status: 400
+        },
+        'checkout-provider-error': {
+            isParams: false,
+            error: 'checkout-provider-error',
+            status: 400
+        },
+        'checkout-request-invalid': {
+            isParams: false,
+            error: 'checkout-request-invalid',
+            status: 400
+        },
+        'checkout-price-invalid': {
+            isParams: false,
+            error: 'checkout-price-invalid',
+            status: 400
+        },
+        'checkout-currency-invalid': {
+            isParams: false,
+            error: 'checkout-currency-invalid',
+            status: 400
+        }
+    }
+}

package/assets/root.fullstackunicorn.dev/backend/server/middleware.auth.js

@@ -0,0 +1,4 @@
+const auth = {}
+auth.getToken = () => 'zzzzzzzz-xxxx-4xxx-8xxx-xxxxxxxxxxxx'
+auth.getUserId = () => 'xxxxxxxx-xxxx-4xxx-8xxx-xxxxxxxxxxxx'
+export { auth }

package/assets/root.fullstackunicorn.dev/backend/server/middleware.js

@@ -0,0 +1,29 @@
+import { errors } from '#@/server/errors.js'
+import { auth } from '#@/server/middleware.auth.js'
+
+class Middleware {
+
+	constructor () {
+		this.token = auth.getToken()
+		this.userId = auth.getUserId()
+	}
+
+	user = async (authorization) => {
+		const user = { id: this.userId }
+        if (authorization === this.token) return user
+        throw new Error("not-authorized") 
+	}
+
+	verify = user => user?.id ?? F3.throw("not-authenticated")
+
+	auth = async (path, request, response, next) => {
+		try {
+			const user = await this.user(request?.headers?.authorization)
+			this.verify(user)
+			request.user = user
+			return next()
+		} catch (error) { return errors.returns(response, path, error) }
+	}
+}
+
+export const middleware = new Middleware()

package/assets/root.fullstackunicorn.dev/backend/server/middleware.prod.js

@@ -0,0 +1,18 @@
+import { auth } from '#@/index.dep.js'
+import { errors } from '#@/server/errors.js'
+
+class Middleware {
+
+	verify = user => user?.id && F3.throw('not-authenticated')
+	auth = async (path, request, response, next) => {
+		try {
+			const user = await auth.user(request.headers?.authorization, request.method)
+			this.verify(user)
+			request.user = user
+			return next()
+		} catch (error) { return errors.returns(response, path, error) }
+	}
+
+}
+
+export const middleware = new Middleware()

package/assets/root.fullstackunicorn.dev/backend/server/resolvers.js

@@ -0,0 +1,21 @@
+import { errors } from '#@/server/errors.js'
+
+class Resolver {
+
+    resolve = async (func, path, request, response, next) => {
+        try {
+            const data = await func(request)
+            return response.status(200).send(data)
+        } catch (error) { return errors.returns(response, path, error) }
+    }
+
+    permission = async ({ func, path, type }, request, response, next) => {
+        try {
+            request.body.change_type = type
+            const data = await func(request)
+            return response.status(200).send(data)
+        } catch (error) { return errors.returns(response, path, error) }
+    }
+}
+
+export const resolver = new Resolver ()