@agung_dhewe/webapps 1.1.2

package/src/sequencerline.js

@@ -0,0 +1,214 @@
+import sqlUtil from '@agung_dhewe/pgsqlc'
+
+const MAX_LENGTH = 12
+const tablename = "core.sequencer_line"
+
+
+export function createSequencerLine(db, options) {
+	return new Sequencer(db, options)
+}
+
+
+class Sequencer {
+	
+	
+	#defaultOptions = {}
+
+
+	db
+	options 
+
+
+	constructor(db, opt) {
+		this.db = db
+		this.options = {
+			...this.#defaultOptions,
+			...opt
+		}
+	}
+
+
+
+
+
+
+	async increment(doc_id) {
+		const self = this
+		const db = self.db
+		try {
+			const { year, month } = await getDbCurrentDate(db)
+			return await generateId(self, year, month, doc_id)
+		} catch (err) {
+			throw err
+		}
+	}
+
+	// 9 digit, untuk tipe integer
+	async yearlyshort(doc_id) {
+		const self = this
+		const db = self.db
+		try {
+			const month = 0
+			const { year } = await getDbCurrentDate(db)
+			return await generateId(self, year, month, doc_id, true)
+		} catch (err) {
+			throw err
+		}
+	}
+
+}
+ 
+
+async function generateId(self, year, month, doc_id, short=false) {
+	const options = self.options
+	const db = self.db
+	const searchMap = {
+		seqnum: `sequencer_seqnum=\${seqnum}`,
+		year: `sequencer_year=\${year}`,
+		month: `sequencer_month=\${month}`
+	};
+
+	sqlUtil.connect(db)
+
+	try {
+
+		// ambil code doc
+		const docparam = { doc_id }
+		const sqldoc = `select doc_seqnum from core.doc where doc_id=\${doc_id}`
+		const row = await db.oneOrNone(sqldoc, docparam)
+		const seqnum = row!=null ? row.doc_seqnum : 0
+
+
+		if (seqnum<0 || seqnum>99) {
+			throw new Error(`doc_id: '${doc_id}' has doc seqnum '${seqnum}' that is invalid. doc seqnum have to in range 1-99 `)
+		}
+
+
+
+		// hitung total panjang bigint yang akan dihailkan
+		let nlength = 0
+		if  (month==0) {
+			// yearly
+			nlength += 2
+		} else {
+			// montly
+			nlength += 4
+		}
+
+		if (seqnum>0) {
+			nlength += 2 
+		}
+
+
+
+		// 25 09 01 000402 0000009
+
+		const ln = nlength + self.options.numberLength
+		
+		if (short) {
+			if (ln > 9) {
+				throw new Error(`Total length of sequencer (${ln}) is mre than max length allowed(9)`)
+			}
+		} else {
+			if (ln > MAX_LENGTH) {
+				throw new Error(`Total length of sequencer (${ln}) is mre than max length allowed(${MAX_LENGTH})`)
+			}
+		}
+
+
+		// ambil data sequencer
+		{
+			const criteria = { year, month, seqnum }
+			const {whereClause, queryParams} = sqlUtil.createWhereClause(criteria, searchMap) 
+	
+			const columns = [
+				'sequencer_id',
+				'sequencer_year',
+				'sequencer_month',
+				'sequencer_seqnum',
+				'sequencer_number',
+				'EXTRACT(YEAR FROM sequencer_lastdate) AS lastyear',
+				'EXTRACT(MONTH FROM sequencer_lastdate) AS lastmonth'
+			]
+
+			const sql = sqlUtil.createSqlSelect({tablename, columns, whereClause, sort:{}, limit:0, offset:0, queryParams}) + ' for update'
+			const row = await db.oneOrNone(sql, queryParams)
+
+			const obj = {}
+
+			if (row!=null) {
+				// console.log(row)
+				obj.sequencer_id = row.sequencer_id
+				obj._modifyby = 0
+				obj._modifydate = (new Date()).toISOString()
+				obj.sequencer_number = row.sequencer_number+1
+				const cmd =  sqlUtil.createUpdateCommand(tablename, obj, ['sequencer_id'])
+				await cmd.execute(obj)
+			} else {
+				obj._createby = 0
+				obj._createdate = (new Date()).toISOString()
+				obj.sequencer_year = year,
+				obj.sequencer_month = month
+				obj.sequencer_seqnum = seqnum
+				obj.sequencer_number = 1
+				obj.sequencer_lastdate = (new Date()).toISOString()
+				obj.sequencer_remark = doc_id
+				const cmd = sqlUtil.createInsertCommand(tablename, obj, ['sequencer_id'])
+				await cmd.execute(obj)
+			}
+
+			// compose generated id
+			const YY = String(year-2000).padStart(2, '0')
+			const MM = String(month).padStart(2, '0')
+
+
+			const tokennum = []
+			if (short) {
+				// hanya tahun
+				tokennum.push(YY)
+			} else {
+				// tahun dan bulan
+				tokennum.push(YY)
+				tokennum.push(MM)
+			}
+
+			
+
+			if (seqnum>0) {
+				tokennum.push(String(seqnum).padStart(2, '0'))
+			}
+
+			
+			//  250901999999
+			// 2509019999999
+			const maxlen = short ? 9 : MAX_LENGTH
+			const idpref = tokennum.join('')
+			const numlen = maxlen - idpref.length
+			tokennum.push(String(obj.sequencer_number).padStart(numlen, '0'))
+
+			const s =  tokennum.join('')
+			return s
+		}
+	} catch (err) {
+		throw err
+	}
+}
+
+async function getDbCurrentDate(db) {
+	try {
+		const sql = "SELECT EXTRACT('year' FROM CURRENT_DATE) AS year, EXTRACT('month' FROM CURRENT_DATE) AS month"
+		const row = await db.one(sql)
+
+		const ret = {
+			year: row.year,
+			month: row.month
+		}
+
+		return ret
+	} catch (err) {
+		throw err
+	}
+}
+
+
+

package/src/session.js

@@ -0,0 +1,57 @@
+import session from 'express-session'; // session
+import { createClient } from 'redis'; // session
+import * as connectRedis from 'connect-redis';  // session
+
+
+export async function createSession(options) {
+
+	const redisUrl = options.redisUrl || 'redis://localhost:6379'
+	const sessionName =  options.sessionName || 'sid'
+	const sessionSecret = options.sessionSecret || 'rahasia'
+	const sessionMaxAge = options.sessionMaxAge || 15 * 50 * 1000 // default 15 menit
+	const sessionDomain = options.sessionDomain || 'localhost'
+	const sessionSecure = options.sessionSecure ?? false
+	const sessionHttpOnly = options.sessionHttpOnly ?? true
+
+	const RedisStore = connectRedis.RedisStore;
+
+
+	console.log(`connecting to redis ${redisUrl}`)
+	const redisClient = createClient({
+		url: redisUrl
+	});
+	await redisClient.connect(); 
+	console.log('connected to redis server.')
+
+	const redisStore = new RedisStore({
+		client: redisClient,
+		prefix: 'sess:',
+	});
+
+
+	const sessionConfig = {
+		name: sessionName,
+		store: redisStore,
+		secret: sessionSecret,
+		resave: false,
+		saveUninitialized: false,
+		rolling: true,
+		cookie: {
+			secure: sessionSecure,
+			httpOnly: sessionHttpOnly,
+			maxAge: sessionMaxAge,
+			domain: sessionDomain
+		}
+	}
+
+	// TODO: tambahkan untuk keperluan ini
+	// domain: '.example.com',       // ✅ Cookie tersedia untuk semua subdomain
+	// path: '/',                    // ✅ Berlaku untuk semua path
+	// secure: true,                 // ✅ Hanya dikirim lewat HTTPS
+	// httpOnly: true,              // ✅ Tidak bisa diakses dari JavaScript
+	// sameSite: 'none',            // ✅ Bisa lintas domain (harus paired dengan secure)
+	// maxAge: 15 * MINUTE,	
+
+	console.log('starting session manager.')
+	return session(sessionConfig)
+}

package/src/startup.js

@@ -0,0 +1,59 @@
+
+export async function authorizeRequest(db, req) {
+	const moduleName = req.params.modulename;
+	const program_id = req.query.prog; 
+
+	try {
+
+		// jika belum login
+		if (req.session.user==null) {
+			const err = new Error(`Belum login. Anda harus <a href="login">login</a> dulu untuk mengakses resource ini`)
+			err.status = 401
+			err.code = 401
+			throw err
+		}
+
+		const user_id = req.session.user.userId
+		const user_fullname = req.session.user.userFullname
+		const developerAccess = req.session.user.developerAccess
+
+
+		// jika punya akses developer boleh buka semuanya
+		const sqlUser = 'select * from core.user where user_id=${user_id} and user_isdev=true'
+		const rowUser = await db.oneOrNone(sqlUser, {user_id})
+		if (rowUser!=null) {
+			return true  // user adalah developer
+		}
+
+		// jika tidak punya akses developer, cek apakah boleh buka program 
+		const sql = 'select * from core.get_user_programs(${user_id}) where id=${program_id}'
+		const row = await db.oneOrNone(sql, {user_id, program_id});
+		if (row!=null) {
+			return true  // user punya akses program
+		}
+
+		const err = new Error(`user '${user_fullname}' tidak diperbolehkan mengakses program '${moduleName}'`)
+		err.status = 401
+		err.code = 401
+		throw err
+
+	} catch(err) {
+		throw err
+	}
+}
+
+export async function getApplicationSetting(db) {
+	const setting = {}
+	try {
+		const sql = 'select setting_id, setting_value from core.setting'
+		const rows = await db.any(sql);
+		for (var row of rows) {
+			const setting_id = row.setting_id
+			const setting_value = row.setting_value
+			setting[setting_id] = setting_value
+		}
+		return setting
+	} catch (err) {
+		throw err
+	}
+}

package/src/webapps.js

@@ -0,0 +1,239 @@
+import ExpressServer from 'express';
+import { createSession } from './session.js'
+import context from './context.js'
+import { createBasicRouter, uploader } from './router.js'
+import { handleModuleNotfound } from './routers/handleModuleNotfound.js'
+import { fileURLToPath } from 'node:url';
+import cors from 'cors';
+import favicon from 'serve-favicon';
+import * as path from 'node:path';
+import * as helper from './helper.js'
+
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+
+
+
+const defaultPort = 3000
+const defaultRedisUrl = 'redis://localhost:6379'
+const defaultSessionName = 'sid'
+const defaultSessionSecret = 'rahasia'
+const defaultSessionMaxAge = 15
+const defaultSessionDomain = 'localhost'
+const defaultSessionSecure = false
+const defaultSessionHttpOnly = true
+
+
+const defaultNotifierSocket = 'ws://localhost:8080'
+const defaultNotifierServer = 'http://localhost:8080'
+
+
+export function createWebApplication() {
+	const webapp = new WebApplication()
+	return webapp
+}
+
+
+export default class WebApplication {
+	#startedOnce
+	#express = ExpressServer();
+
+	get defaultPort() { return defaultPort }
+	get defaultRedisUrl() { return defaultRedisUrl }
+	get defaultNotifierSocket() { return defaultNotifierSocket }
+	get defaultNotifierServer() { return defaultNotifierServer }
+	get defaultSessionName() { return defaultSessionName }
+	get defaultSessionSecret() { return defaultSessionSecret }
+	get defaultSessionMaxAge() { return defaultSessionMaxAge }
+	get defaultSessionDomain() { return defaultSessionDomain }
+	get defaultSessionSecure() { return defaultSessionSecure }
+	get defaultSessionHttpOnly() { return defaultSessionHttpOnly }
+
+	get express() { return this.#express}
+
+	#__rootDirectory
+	get __rootDirectory() { return this.#__rootDirectory }
+	setRootDirectory(v) { 
+		this.#__rootDirectory = v
+	}
+
+
+	constructor() {
+		context.setWebappsDirectory(path.join(__dirname, '..'))
+	}
+
+	start(options) {
+		if (this.__rootDirectory == undefined) {
+			throw new Error('__rootDirectory belum didefinisikan')
+		}
+
+		context.setRootDirectory(this.__rootDirectory)	
+		context.setFnParseModuleRequest(options.fnParseModuleRequest)
+
+		if (this.#startedOnce) {
+			throw new Error('start already called!')
+		}
+		this.#startedOnce = true
+
+		// malai rutin utama untuk menjalankan server
+		main(this, options)
+	}
+
+	
+}
+
+
+export function createDefaultAppConfig() {
+	const sessionName = defaultSessionName
+	const sessionSecret = defaultSessionSecret
+	const sessionMaxAge = defaultSessionMaxAge
+	const sessionDomain = defaultSessionDomain
+	const sessionSecure = defaultSessionDomain
+	const sessionHttpOnly = defaultSessionHttpOnly
+
+	const notifierSocket = defaultNotifierSocket
+	const notifierServer = defaultNotifierServer
+
+	const redisUrl = defaultRedisUrl
+
+	return {
+		sessionName,
+		sessionSecret,
+		sessionMaxAge,
+		sessionDomain,
+		sessionSecure,
+		sessionHttpOnly,
+
+		notifierSocket,
+		notifierServer,
+		redisUrl
+	}
+}
+
+
+async function main(self, options) {
+	const __rootDirectory = self.__rootDirectory
+
+	const app = self.express
+	const port = options.port ?? self.defaultPort
+	const startingMessage = options.startingMessage ?? `Starting webserver on port \x1b[1;33m${port}\x1b[0m`
+	const appConfig = options.appConfig || createDefaultAppConfig()
+	
+	const basicRouter = createBasicRouter()
+	const extendedRouter = options.router || ExpressServer.Router({ mergeParams: true });
+	const router = ExpressServer.Router({ mergeParams: true });
+
+
+	const redisUrl = appConfig.redisUrl
+	const notifierSocket = appConfig.notifierSocket
+	const notifierServer = appConfig.notifierServer
+
+	const sessionName = appConfig.sessionName
+	const sessionSecret = appConfig.sessionSecret
+	const sessionMaxAge = appConfig.sessionMaxAge
+	const sessionDomain = appConfig.sessionDomain
+	const sessionSecure = appConfig.sessionSecure
+	const sessionHttpOnly = appConfig.sessionHttpOnly
+
+	const session = await createSession({ redisUrl, sessionName, sessionSecret, sessionMaxAge, sessionDomain, sessionSecure, sessionHttpOnly })
+
+
+	router.use(uploader)
+
+	router.use(extendedRouter) // extended akan dipanggil dahulu, sehingga akan meng-override basicRouter
+	router.use(basicRouter)
+
+
+	// setup variabel konfigurasi local, nanti bisa diakses dari router/api
+	app.locals.appConfig = appConfig
+
+
+
+	// konfigurasi applikasi
+	app.set('trust proxy', true); // ini nanti diisi daftar host yang dipercaya sebagai proxy, baca dari env
+	app.set("view engine", "ejs");
+	app.set("views", [
+		path.join(__rootDirectory, "views"),
+		path.join(__rootDirectory, 'public', 'modules')
+	]);
+
+	// setup cors
+	if (options.allowedOrigins!=null) {
+		const allowedOrigins = options.allowedOrigins
+		app.use(cors({
+			origin: function (origin, callback) {
+				if (!origin) return callback(null, true); // untuk server-side atau curl
+				const isAllowed = allowedOrigins.some(o => {
+					if (typeof o === 'string') return o === origin;
+					if (o instanceof RegExp) return o.test(origin);
+					return false;
+				});
+
+				if (isAllowed) {
+					callback(null, true);
+				} else {
+					callback(new Error('Not allowed by CORS'));
+				}
+			},
+			// methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+			// allowedHeaders: ['Content-Type', 'Authorization'],
+			// credentials: true
+		}));
+	} else {
+		app.use(cors());
+	}
+
+
+
+	// setup middleware
+	app.use(favicon(path.join(__rootDirectory, 'public', 'favicon.ico')));
+	app.use(ExpressServer.json());
+	app.use(ExpressServer.urlencoded({ extended: true }));
+	app.use(session);
+
+
+	// framework ini menggunakan library fgta5 untuk ui di client
+	if (appConfig.fgta5jsDebugMode) {
+		app.use('/public/libs/fgta5js', ExpressServer.static(path.join(__dirname, '..', 'libs', 'fgta5js')));
+	} else {
+		app.use('/public/libs/fgta5js', ExpressServer.static(path.join(__dirname, '..', 'libs', 'fgta5js-dist')));
+	}
+	
+	app.use('/public/libs/webmodule', ExpressServer.static(path.join(__dirname, '..', 'libs', 'webmodule')));
+	
+	// Routing /public  untuk serve halaman-halaman static
+	app.use('/public', rejectEjsFiles);
+	app.use('/public', ExpressServer.static(path.join(__rootDirectory, 'public')));
+	app.use('/', router)
+	app.use(handleModuleNotfound)
+	
+
+	const server = app.listen(port, ()=>{
+		console.log('\n\n' + startingMessage);
+	});
+
+	// Tangani event 'error' pada objek server
+	server.on('error', (err) => {
+		if (err.code === 'EADDRINUSE') {
+			console.error(`\n\x1b[31mError!\x1b[0m\nPort ${port} sudah digunakan. Silakan coba port lain.\n`);
+		} else {
+			console.error('\n\x1b[31mError!\x1b[0m\nTerjadi kesalahan saat memulai server:', err, "\n");
+		}
+		// Anda bisa memutuskan untuk keluar dari aplikasi atau mencoba port lain
+		process.exit(1); // Keluar dengan kode error
+	});
+}
+
+
+function rejectEjsFiles(req, res, next) {
+	const excludedExtensions = ['.ejs']; 
+	const ext = path.extname(req.url);
+
+	if (excludedExtensions.includes(ext)) {
+		return res.status(403).send('Akses ke file ini tidak diperbolehkan');
+	}
+
+	next();
+}

package/src/workermanager.js

@@ -0,0 +1,83 @@
+import { Worker } from 'worker_threads';
+
+
+export const runDetachedWorker = (workerPath, notifierServer, clientId, options) => {
+	const timeout = options.timeout || 10000
+
+	// cek dulu apakah valid
+	try {
+		if (clientId==null || notifierServer==null) {
+		throw new Error('clientId / notifierServer belum didefinisikan di parameter runDetachedWorker')  
+		}
+	} catch (err) {
+		throw err
+	}
+
+
+	console.log('Starting worker')
+	const worker = new Worker(workerPath, {
+		workerData: options
+	});
+
+	const timeoutId = setTimeout(() => {
+		console.warn('Worker timeout, terminating...');
+		notifyClient(notifierServer, clientId, 'timeout')     // nofify ke clent, kalau timeout
+		worker.terminate();
+	}, timeout);
+
+	worker.on('message', (info) => {
+		clearTimeout(timeoutId);
+		console.log('Worker message:', 'message', info);
+		if (info.done===true) {
+			notifyClient(notifierServer, clientId, 'done', info)     // nofify message ke clent
+			// worker.terminate(); // Optional: let it exit naturally if preferred
+		} else {
+			notifyClient(notifierServer, clientId, 'message', info)     // nofify message ke clent
+		}
+	});
+
+	worker.on('error', (err) => {
+		clearTimeout(timeoutId);
+		console.error('Worker error:', err);
+		notifyClient(notifierServer, clientId, 'error', {message: err.message})     // nofify error ke clent
+		worker.terminate();
+	});
+
+	worker.on('exit', (code) => {
+		clearTimeout(timeoutId);
+		notifyClient(notifierServer, clientId, 'done', {})  
+		console.log(`🚪 Worker exited with code ${code}`);
+	});
+};
+
+
+
+async function notifyClient(notifierServer, clientId, status, info) {
+	try {
+		console.log(status)
+		console.log('notify to:' , notifierServer)
+		console.log(clientId)
+
+		const data = {clientId, status, info}
+		const url = `${notifierServer}/notify`
+		const response = await fetch(url, {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify(data)
+		});
+
+		if (!response.ok) {
+			const status = response.status
+			const statustext = response.statusText
+			const err = new Error(`${status} ${statustext}: ${options.method} ${url}`)
+			err.code = status
+			throw err
+		}
+		
+		return response
+	} catch (err) {
+		throw err
+	}
+}

package/templates/_lib_debug.ejs

@@ -0,0 +1,11 @@
+
+			<!-- Component -->
+			<script type="module" src="public/libs/fgta5js/src/main.mjs"></script>
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-root.css" />
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-messagebox.css" />
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-modal.css" />
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-entry.css" />
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-checkbox.css" />
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-gridview.css" />
+			<link rel="stylesheet" href="public/libs/fgta5js/styles/fgta5js-appmanager.css" />
+

package/templates/_lib_production.ejs

@@ -0,0 +1,5 @@
+
+			<!-- Component -->
+			<script src="public/libs/fgta5js/fgta5js-<%=fgta5jsVersion%>.min.js"></script>
+			<link rel="stylesheet" href="public/libs/fgta5js/fgta5js-<%=fgta5jsVersion%>.min.css" /> 
+