@agung_dhewe/webapps 1.1.2

package/src/generator/worker.js

@@ -0,0 +1,389 @@
+import path from 'path';
+import pgp from 'pg-promise'
+import db from '../db.js'
+import { workerData, parentPort } from 'worker_threads';
+import { access, mkdir } from 'fs/promises';
+import { constants } from 'fs';
+
+import { isFileExist } from './helper.js'
+
+import { createModuleRollup } from './createModuleRollup.js'
+import { createModuleContext } from './createModuleContext.js'
+import { createModuleExtenderMjs } from './createModuleExtenderMjs.js'
+import { createModuleExtenderHtml } from './createModuleExtenderHtml.js'
+import { createModuleEjs } from './createModuleEjs.js'
+import { createModuleMjs } from './createModuleMjs.js'
+import { createModuleHeaderListHtml } from './createModuleHeaderListHtml.js'
+import { createModuleHeaderListMjs } from './createModuleHeaderListMjs.js'
+import { createModuleHeaderEditHtml } from './createModuleHeaderEditHtml.js'
+import { createModuleHeaderEditMjs } from './createModuleHeaderEditMjs.js'
+import { createModuleDetilListHtml } from './createModuleDetilListHtml.js'
+import { createModuleDetilListMjs } from './createModuleDetilListMjs.js'
+import { createModuleDetilEditHtml } from './createModuleDetilEditHtml.js'
+import { createModuleDetilEditMjs } from './createModuleDetilEditMjs.js'
+import { createApiModule } from './createApiModule.js'
+import { createApiExtenderModule } from './createApiExtenderModule.js'
+import { createTable } from './createTable.js';
+import { createInfoAboutExtender } from './createInfoAboutExtender.js';
+import { createInfoLogs } from './createInfoLogs.js';
+import { createInfoRecordExtender } from './createInfoRecordExtender.js';
+import { createIcon } from './createIcon.js'
+import { createProgramData } from './createProgramData.js'
+
+
+
+const { generator_id, user_id, user_name, ipaddress, jeda } = workerData;
+
+
+main(generator_id)
+
+
+async function main(id) {
+	try {
+		const queryParams = {generator_id: id}
+		const sql = 'select generator_data from core."generator" where generator_id = \${generator_id}'
+		const data = await db.one(sql, queryParams);
+
+
+		// cek dahulu apakah directory tujuan benar
+		// console.log(data)
+
+
+		await generate(id, data.generator_data)
+		
+		
+	} catch (err) {
+		err.message = `Generator Worker: ${err.message}`
+		throw err
+	}
+}
+
+async function sleep(s) {
+	if (s==0) {
+		return
+	}
+
+	return new Promise(lanjut=>{
+		setTimeout(()=>{
+			lanjut()
+		}, s*1000)	
+	})
+}
+
+async function generate(id, data) {
+
+	const now = new Date();
+
+	const options = {
+		day: 'numeric',
+		month: 'short',
+		year: 'numeric',
+		hour: '2-digit',
+		minute: '2-digit',
+		hour12: false,
+	};
+
+	const formattedTime = now.toLocaleString('en-GB', options).replace(',', '');
+
+
+	const context = {
+		id:id,
+		user_id: user_id,
+		user_name: user_name, 
+		ipaddress: ipaddress,
+		title: data.title,
+		descr: data.description,
+		directory: data.directory,
+		appname: data.appname,
+		moduleName: data.name,
+		entities: data.entities,
+		icon: data.icon,
+		timeGenerated: formattedTime,
+		postMessage: (info) => {
+			parentPort.postMessage(info)
+		}
+	}
+
+	const jedaWaktu = jeda ?? 0
+
+
+
+
+	// tambahkan referensi ke entity detil
+	const entityHeader = context.entities['header']
+	const headerPkFieldName = entityHeader.pk
+	const headerItems = entityHeader.Items
+	for (var entityName in context.entities) {
+		// tambahkan jika bukan header
+		if (entityName!='header') {
+			const headerPK = structuredClone(headerItems[headerPkFieldName])
+			headerPK.Reference.pk = entityHeader.pk
+			headerPK.Reference.table = entityHeader.table
+			headerPK.Reference.bindingValue = entityHeader.pk
+			headerPK.input_disabled = true
+			context.entities[entityName].Items[entityHeader.pk] = headerPK
+		}
+	}
+
+
+	try {
+
+		await checkEntitiy(context)
+		// process.exit(0)
+
+
+		await prepareDirectory(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+
+		
+		const iconFileName = await createIcon(context, {overwrite:true})
+
+		await createProgramData(context, {iconFileName})
+	
+		await createTable(context, {overwrite:true})
+		await sleep(jedaWaktu)
+		
+		await createApiModule(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+
+		
+		await createModuleRollup(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+		await createModuleContext(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+		
+
+		await createModuleEjs(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+		
+		await createModuleMjs(context, {overwrite:true, iconFileName})
+		await sleep(jedaWaktu)
+
+
+
+		// Header
+		await createModuleHeaderListHtml(context, {overwrite:true})
+		await sleep(jedaWaktu)
+		
+
+		await createModuleHeaderListMjs(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+		
+		await createModuleHeaderEditHtml(context,  {overwrite:true})
+		await sleep(jedaWaktu)
+
+		
+		await createModuleHeaderEditMjs(context, {overwrite:true})
+		await sleep(jedaWaktu)
+	
+
+		
+		// Detils
+		await createModuleDetilListHtml(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+		await createModuleDetilListMjs(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+
+		await createModuleDetilEditHtml(context, {overwrite:true})
+		await sleep(jedaWaktu)
+		
+		await createModuleDetilEditMjs(context, {overwrite:true})
+		await sleep(jedaWaktu)
+		
+
+		await createInfoLogs(context, {overwrite:true})
+		await sleep(jedaWaktu)
+
+
+		// Extender
+		await createApiExtenderModule(context, {overwrite:false})
+		await sleep(jedaWaktu)
+
+		await createModuleExtenderHtml(context, {overwrite:false})
+		await sleep(jedaWaktu)
+
+		await createModuleExtenderMjs(context, {overwrite:false})
+		await sleep(jedaWaktu)
+
+		await createInfoAboutExtender(context, {overwrite:false})
+		await sleep(jedaWaktu)
+
+		await createInfoRecordExtender(context, {overwrite:false})
+		await sleep(jedaWaktu)
+		
+	
+
+
+		// Selesai
+		context.postMessage({message: `finish`, done:true})
+	} catch (err) {
+		throw err
+	}
+}
+
+async function prepareDirectory(context) {
+	const appname = context.appname
+	const moduleName = context.moduleName
+	const directory = context.directory
+
+
+	try {
+
+		context.postMessage({message: `preparing directory`})
+		// await sleep(1)
+
+		// cek jika directory project exists
+		const projectDirExists = await directoryExists(directory)
+		if (!projectDirExists) {
+			throw new Error(`directory tujuan '${directory}' tidak ditemukan`)
+		}
+
+		const moduleDir = path.join(directory, 'public', 'modules', moduleName)
+		const apiDir = path.join(directory, 'src', 'apis')
+		const apiExtenderDir = path.join(apiDir, 'extenders')
+
+		const moduleDirExists =  await directoryExists(moduleDir)
+		if (!moduleDirExists) {
+			// direktori modul tidak ditemukan, buat dulu
+			context.postMessage({message: `creating new directory: '${moduleDir}`})
+			await mkdir(moduleDir, {});
+			// await sleep(1)
+		}
+
+		const apiDirExists =  await directoryExists(apiDir)
+		if (!apiDirExists) {
+			throw new Error(`directory tujuan '${apiDir}' tidak ditemukan`)
+		}
+
+		const apiExtenderDirExists =  await directoryExists(apiExtenderDir)
+		if (!apiExtenderDirExists) {
+			throw new Error(`directory tujuan '${apiExtenderDir}' tidak ditemukan`)
+		}
+
+
+		// cek apakah sudah di lock
+		const lockFile = path.join(moduleDir, `${moduleName}.lock`)
+		var fileExists = await isFileExist(lockFile)
+		if (fileExists) {
+			console.log("\n\n\x1b[1m\x1b[31mERROR\x1b[0m")
+			console.log('Module sudah di lock, tidak bisa digenerate ulang')
+			process.exit(1)
+		}  
+
+
+		context.moduleDir = moduleDir
+		context.apiDir = apiDir
+		context.apiExtenderDir = apiExtenderDir
+	} catch (err) {
+		throw err
+	}
+}
+
+
+
+async function directoryExists(path) {
+	try {
+		await access(path, constants.F_OK);
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+async function checkEntitiy(context) {
+	const apps = []
+	try {
+		const sql = "select * from core.apps"
+		const rows = await db.any(sql)
+		for (let row of rows) {
+			apps[row.apps_id] = row
+		}
+	} catch (err) {
+		throw err
+	}
+
+
+	// cek appname
+	if (apps[context.appname]==null) {
+		throw new Error(`App Name: '${context.appname}' tidak valid. Cek di data apps`)
+	}
+
+
+	// process.exit(1)
+
+	for (let entityName in context.entities) {
+		const entity = context.entities[entityName]
+		const entity_table = entity.table
+		const entity_pk = entity.pk
+		const Items = entity.Items
+		
+		let pkExists = false	
+
+		for (let fieldName in Items) {
+			const item = Items[fieldName]
+			const component = item.component
+
+			// Cek Primary Key
+			if (fieldName==entity_pk) {
+				pkExists = true
+				if (!item.showInForm) {
+					throw new Error(`Primary key '${fieldName}' pada entity '${entityName}' harus di embed di form. Apabila ingin menyembunyakannya, gunakan 'hidden' di Container CSS `)
+				}
+			}
+
+			// Cek combobox
+			if (component=='Combobox') {
+				// cek apakah konfig udah bener
+				const reference = item.Reference
+				const table = reference.table.trim()
+				const pk = reference.pk.trim()
+				const bindingValue = reference.bindingValue.trim()
+				const bindingText = reference.bindingText.trim()
+				const loaderApiModule = reference.loaderApiModule.trim()
+				const loaderApiPath = reference.loaderApiPath.trim()
+
+				if(table=='') {
+					throw new Error(`table reference Combobox '${fieldName}' di entity '${entityName}' tidak boleh kosong`)
+				}
+
+				if(pk=='') {
+					throw new Error(`PK untuk table reference Combobox '${fieldName}' di entity '${entityName}' tidak boleh kosong`)
+				}
+				
+				if(bindingValue=='') {
+					throw new Error(`binding value untuk table reference Combobox '${fieldName}' di entity '${entityName}' tidak boleh kosong`)
+				}
+
+				if(bindingText=='') {
+					throw new Error(`binding value untuk table reference Combobox '${fieldName}' di entity '${entityName}' tidak boleh kosong`)
+				}
+
+				if(loaderApiModule=='') {
+					throw new Error(`loader API Name untuk table reference Combobox '${fieldName}' di entity '${entityName}' tidak boleh kosong`)
+				}
+
+				if (apps[loaderApiModule]==null) {
+					throw new Error(`loader API Name: '${loaderApiModule}' untuk table reference Combobox '${fieldName}' di entity '${entityName}' tidak valid. Cek di data apps`)
+				}
+
+				if(loaderApiPath=='') {
+					throw new Error(`loader API path untuk table reference Combobox '${fieldName}' di entity '${entityName}' tidak boleh kosong`)
+				}
+			}
+		}
+
+		if (!pkExists) {
+			throw new Error(`Primary key pada entity '${entityName}' belum didefinisikan`)
+		}
+
+
+	}
+}

package/src/helper.js

@@ -0,0 +1,82 @@
+import fs from 'fs/promises';
+import * as path from 'node:path';
+import ejs from 'ejs'
+import context from './context.js'
+
+
+
+export function kebabToCamel(str) {
+  return str
+    .split('-')
+    .map((part, index) =>
+      index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
+    )
+    .join('');
+}
+
+
+export async function importApiModule(modulename, options={}) {
+	// jika mode debug, 
+	// load api akan selalu dilakukan saat request (tanpa caching)
+
+
+	const cached = options.cached===true ? true : false
+	const apiDir = options.apiDir || path.join('.', 'apis')
+	const apiPath = path.join(apiDir, `${modulename}.api.js`)
+
+	if (cached) {
+		return (await import(apiPath)).default;
+	} else {
+		const fullPath = new URL(apiPath, import.meta.url).pathname;
+		const mtime = (await fs.stat(fullPath)).mtimeMs;
+		const freshUrl = `${fullPath}?v=${mtime}`;
+		const module = await import(freshUrl);
+
+		if (module.default===undefined) {
+			throw new Error(`modul api '${modulename}' tidak mempunyai default class untuk import`)
+		}
+
+		return module.default;	
+	}
+}
+
+
+
+
+export async function isFileExists(filepath) {
+	try {
+		await fs.access(filepath);
+		return true
+	} catch (err) {
+		return false
+	}
+}
+
+export async function parseTemplate(tplFilePath, variables={}) {
+	const template =  await fs.readFile(tplFilePath, 'utf-8');
+	const content = ejs.render(template, variables)
+	return content
+}
+
+
+export function createDefaultEjsVariable(req) {
+	const appName = req.app.locals.appConfig.appName || ''
+	const moduleName = req.params.modulename
+	const libDebug = path.join(context.getWebappsDirectory(), 'templates', '_lib_debug.ejs')
+	const libProduction = path.join(context.getWebappsDirectory(), 'templates', '_lib_production.ejs')
+	const fgta5jsDebugMode = req.app.locals.appConfig.fgta5jsDebugMode
+	const fgta5jsVersion = req.app.locals.appConfig.fgta5jsVersion
+	const appDebugMode = req.app.locals.appConfig.appDebugMode
+
+	const variables = {
+		appName,
+		moduleName,
+		libDebug,
+		libProduction,
+		fgta5jsDebugMode,
+		fgta5jsVersion,
+		appDebugMode
+	}
+
+	return variables
+}

package/src/logger.js

@@ -0,0 +1,39 @@
+import { dblog } from './db.js'
+
+
+export default new (class {
+	async access(user, modulename, url, errormessage) {
+		console.log('logger access', modulename, url, errormessage)
+	}
+
+	
+	async log(logdata) {
+		const { id, user_id, user_name, moduleName, action, tablename, executionTimeMs, remark, metadata, ipaddress=''} = logdata
+		const sql = `insert into datalog 
+			(log_time, log_user_id, log_user_name, log_action, log_ipaddress, log_module, log_table, log_doc_id, log_remark, log_executiontime, log_metadata)
+			values
+			(now(), \${log_user_id}, \${log_user_name}, \${log_action}, \${log_ipaddress}, \${log_module}, \${log_table}, \${log_doc_id}, \${log_remark}, \${log_executiontime}, \${log_metadata})
+			RETURNING log_time
+			`
+		const variable = {
+			log_user_id: user_id, 
+			log_user_name: user_name, 
+			log_action: action,  
+			log_ipaddress: ipaddress, 
+			log_module: moduleName, 
+			log_table: tablename, 
+			log_doc_id: id, 
+			log_remark: remark, 
+			log_executiontime: executionTimeMs, 
+			log_metadata: metadata
+		}
+
+		const ret = await dblog.oneOrNone(sql, variable)
+		return ret
+	}
+
+
+})()
+
+
+

package/src/router.js

@@ -0,0 +1,84 @@
+import ExpressServer from 'express'
+import multer from 'multer';
+import fs from 'fs/promises';
+import * as path from 'node:path'
+import * as http from 'node:http' 
+import * as helper from './helper.js'
+import { fileURLToPath } from 'node:url';
+import context from './context.js'
+
+import { defaultRootIndex } from './routers/defaultRootIndex.js'
+import { handleModuleNotfound } from './routers/handleModuleNotfound.js'
+import { handleError } from './routers/handleError.js'
+import { fileUploadApi } from './routers/fileUploadApi.js'
+import { publicDownloadHandler, privateDownloadHandler } from './routers/downloadHandler.js'
+import { defaultLoginPage } from './routers/defaultLoginPage.js'
+import { defaultLoginAsset } from './routers/defaultLoginAsset.js'
+import { defaultLoginApi } from './routers/defaultLoginApi.js'
+import { generatorPage } from './routers/generatorPage.js'
+import { generatorAsset } from './routers/generatorAsset.js'
+import { generatorApi } from './routers/generatorApi.js'
+import { modulePage } from './routers/modulePage.js'
+import { moduleApi } from './routers/moduleApi.js'
+
+
+export default {
+	createBasicRouter: () => { return createBasicRouter() }
+} 
+
+
+export function uploader(req, res, next) {
+	if (req.is('multipart/form-data')) {
+		const upload = multer();
+		upload.any()(req, res, next);
+	} else {
+		next();
+	}
+}
+
+
+
+export function createBasicRouter() {
+	const router = ExpressServer.Router({ mergeParams: true });
+
+	// index
+	router.get('/', defaultRootIndex)
+	
+	
+	// upload
+	router.post('/upload', fileUploadApi)
+	
+	// download
+	router.get('/download', publicDownloadHandler)
+	router.post('/download', privateDownloadHandler)
+
+
+	// login
+	router.get('/login', defaultLoginPage)
+	router.get('/login/:requestedAsset', defaultLoginAsset)
+	router.post('/login/:method', defaultLoginApi)
+	
+	// generator
+	router.get('/generator', generatorPage)
+	router.get('/generator/:requestedAsset', generatorAsset)
+	router.post('/generator/:method', generatorApi)
+
+	
+	// debug
+	// router.get('/debug/:modulename', modulePage)
+	// router.post('/debug/:modulename/:method', moduleApi)
+
+
+	// modul
+	router.get('/:modulename', modulePage)
+	router.post('/:modulename/:method', moduleApi)	
+
+	return router
+}
+
+
+
+
+
+
+

package/src/routers/defaultLoginApi.js

@@ -0,0 +1,29 @@
+import * as helper from './../helper.js'
+import { handleError } from './handleError.js'
+
+
+export async function defaultLoginApi(req, res, next) {
+	const moduleName = 'login'
+	const methodName = req.params.method
+
+	try {
+
+		const ModuleClass = await helper.importApiModule(moduleName)
+		const method = helper.kebabToCamel(methodName);
+		if (ModuleClass===undefined) {
+			throw new Error(`invalid module: '${moduleName}'`)
+		}
+
+		const requestedBody = req.body
+		const module = new ModuleClass(req, res, next)
+		const result = await module.handleRequest(method, requestedBody)
+		const response = {
+			code: 0,
+			result: result
+		}
+		res.json(response)
+	} catch (err) {
+		handleError(err, req, res)
+	}
+	
+}

package/src/routers/defaultLoginAsset.js

@@ -0,0 +1,18 @@
+import context from './../context.js'
+import * as helper from './../helper.js'
+import * as path from 'node:path'
+import { handleError } from './handleError.js'
+
+
+export async function defaultLoginAsset(req, res, next) {
+	const __dirname = context.getWebappsDirectory()
+	const requestedFile = req.params.requestedAsset;
+	const filePath = path.join(__dirname, 'modules', 'login', requestedFile)
+
+	const assetExists = await helper.isFileExists(filePath)
+	if (assetExists) {
+		res.sendFile(filePath)
+	} else {
+		res.status(404).send(`'${requestedFile}' is not found`)
+	}
+}

package/src/routers/defaultLoginPage.js

@@ -0,0 +1,36 @@
+import context from './../context.js'
+import * as helper from './../helper.js'
+import * as path from 'node:path'
+import { handleError } from './handleError.js'
+
+export async function defaultLoginPage(req, res, next) {
+	const __dirname = context.getWebappsDirectory()
+
+	try {
+
+		const loginPagePath = path.join(__dirname, 'modules', 'login', 'login.html')
+
+		const variables	= {
+			...helper.createDefaultEjsVariable(req),
+			...{
+				loginPagePath
+			}
+		}
+
+		const tplFilePath = path.join(__dirname, 'templates', 'login.page.ejs')
+		const content = await helper.parseTemplate(tplFilePath, variables)
+
+		res.status(200).send(content)		
+		// res.status(200).send(`defaultLoginApi`)	
+
+	} catch (err) {
+		// next(err)
+		handleError(err, req, res)
+	}
+
+
+
+}
+
+
+

package/src/routers/defaultRootIndex.js

@@ -0,0 +1,16 @@
+import context from './../context.js'
+import * as helper from './../helper.js'
+import * as path from 'node:path'
+
+
+export async function defaultRootIndex(req, res, next) {
+	const variables	= {
+		...helper.createDefaultEjsVariable(req),
+		...{
+
+		}
+	}
+	const tplFilePath = path.join(context.getWebappsDirectory(), 'templates', 'index.page.ejs')
+	const content = await helper.parseTemplate(tplFilePath, variables)
+	res.status(200).send(content)
+}