corebasic 1.0.230 → 1.0.232

package/libs/messaging.ts

@@ -9,24 +9,85 @@ import { createClient } from 'redis';
 const url = process.env.REDIS_URL || "redis://localhost:6380"
 
 // url: 'redis://alice:foobared@localhost:6380'
-let consumer, publisher
 
 
+type RedisListener = (message: string, channel: string) => void
 
-let users_pool = {
+type RedisConsumer = {
+    connect: () => Promise<void>
+    subscribe: (channel: string, listener: RedisListener) => Promise<void>
+    unsubscribe: (channel: string, listener: RedisListener) => Promise<void>
+    on: (event: string, listener: (err: unknown) => void) => void
+}
+
+type RedisPublisher = {
+    connect: () => Promise<void>
+    publish: (channel: string, message: string) => Promise<unknown>
+}
+
+type Request = {
+    body: {
+        client: string
+    }
+    params: {
+        user: string
+    }
+    on: (event: string, listener: () => void | Promise<void>) => void
+}
+
+type Response = {
+    writeHead: (status: number, headers: Record<string, string>) => void
+    write: (data: string) => void
+    flush?: () => void
+    end: () => void
+    json: (body: unknown) => void
+}
+
+type UserRequest = {
+    req: Request
+    res: Response
+    uid: string
+}
 
+type UserListeners = {
+    count: number
+    [uid: string]: number | RedisListener
 }
 
-async function disconnect(user, uid) {
+type UserPool = {
+    reqres: UserRequest[]
+    listeners: UserListeners
+}
+
+export type ExpressApp = {
+    get: (
+        path: string,
+        handler: (req: Request, res: Response) => Promise<void>
+    ) => unknown
+}
+
+
+let consumer: RedisConsumer
+let publisher: RedisPublisher
+
+
+let users_pool: Record<string, UserPool> = {}
+
+
+async function disconnect(user: string, uid: string) {
     if (!users_pool[user])
         return
 
-    let [{res}] = users_pool[user].reqres.filter(item => item.uid === uid).concat([{}])
-    res.end()
+
+    let res_items = users_pool[user].reqres.filter(item => item.uid === uid)
+    if (res_items) {
+        const res = res_items[0]!.res
+        res.end()
+    }
 
     if (users_pool[user].listeners[uid]) {
         if (users_pool[user].listeners.count == 1)
-            await consumer.unsubscribe(user, users_pool[user].listeners[uid]);
+            await consumer.unsubscribe(user, users_pool[user].listeners[uid]  as RedisListener);
         users_pool[user].listeners.count --
     }
     users_pool[user].reqres = users_pool[user].reqres.filter(item => item.uid !== uid)
@@ -36,9 +97,9 @@ async function disconnect(user, uid) {
 
     // await consumer.unsubscribe(user);
 }
-async function connect({user,req,res, uid}) {
+async function connect({user, req, res, uid}: {user: string, req: Request, res: Response, uid: string}) {
     res.writeHead(200, {'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive'})
-    const listener = (message, channel) => {
+    const listener = (message: string, channel: string) => {
         if (users_pool[user]) {
             try {message = JSON.parse(message)} catch {}
             for (let {req, res} of users_pool[user].reqres) {
@@ -56,7 +117,7 @@ async function connect({user,req,res, uid}) {
     users_pool[user].listeners.count ++
 }
 
-export async function start(app) {
+export async function start(app: ExpressApp) {
     consumer = createClient({ url });
     await consumer.connect();
     publisher = createClient({ url });
@@ -79,7 +140,7 @@ export async function start(app) {
 }
 
 
-export async function publish(channel, message) {
+export async function publish(channel: string, message: object | string) {
     if (publisher && !Utils.isEmpty(channel)) {
         try {
             await publisher.publish(channel, typeof message === "object" ? JSON.stringify(message) : message)
@@ -108,44 +169,44 @@ export async function newProducer() {
 let defaultConsumer = await newConsumer()
 let defaultProducer = await newProducer()
 
-export async function subscribe(channel, listener) {
+export async function subscribe(channel: string, listener: RedisListener) {
     await defaultConsumer.subscribe(channel, listener)
 }
 
-export async function produce(channel, message) {
+export async function produce(channel: string, message: string) {
     await defaultProducer.publish(channel, message)
 }
 
 
 let defaultSetGetConsumer = await newConsumer()
 
-export async function set(key, value) {
+export async function set(key: string, value: object | string | number) {
     await defaultSetGetConsumer.set(`${process.env.REDIS_CHANNEL_PREFIX}_${key}`, typeof value === 'object' ? JSON.stringify(value) : value)
 }
-export async function get(key) {
+export async function get(key: string) {
     let value = await defaultSetGetConsumer.get(`${process.env.REDIS_CHANNEL_PREFIX}_${key}`)
     try { value = JSON.parse(value) } catch(err) { }
     return value
 }
-export async function del(key) {
+export async function del(key: string) {
     await defaultSetGetConsumer.del(`${process.env.REDIS_CHANNEL_PREFIX}_${key}`)
 }
 
-export async function hset(key, subkey, value) {
+export async function hset(key: string, subkey: string, value: object | string | number) {
     await defaultSetGetConsumer.HSET(`${process.env.REDIS_CHANNEL_PREFIX}_${key}`, subkey, typeof value === 'object' ? JSON.stringify(value) : value)
 }
-export async function hget(key, subkey) {
+export async function hget(key: string, subkey: string) {
     let value = await defaultSetGetConsumer.HGET(`${process.env.REDIS_CHANNEL_PREFIX}_${key}`, subkey)
     try { value = JSON.parse(value) } catch(err) { }
     return value
 }
-export async function hdel(key, subkey) {
+export async function hdel(key: string, subkey: string) {
     await defaultSetGetConsumer.HDEL(`${process.env.REDIS_CHANNEL_PREFIX}_${key}`, subkey)
 }
 
 // Hydrate
 
-export async function hydrate(callback) {
+export async function hydrate(callback: () => Promise<{user: string, company: string, items: any[]}>) {
    setTimeout(async () => {
         let {user,company,items} = await callback()
         await publish(user, {event: "RPC_hydrate", data: { company, items }, txn: Utils.uid() })

package/libs/session.ts

@@ -3,7 +3,17 @@ import * as Features from './features.ts'
 // @ts-ignore
 import jwt from 'jsonwebtoken'
 
-let app
+type Req = { header: (h: string) => string; path: string; url: string; body: { staff: string; company: string; outlet: string; app: string; feature: string; } }
+type Res = { json: (body: unknown) => unknown; status: (code: number) => { json: (body: unknown) => unknown };}
+type Next = () => void;
+type Use = (req: Req, res: Res, next: Next) => Promise<void>
+
+type ReqRefreshToken = { body: { userId: string; clientId: string; refreshToken: string } }
+type ResRefreshToken = { json: (body: unknown) => unknown; status: (code: number) => { json: (body: unknown) => unknown };}
+
+type ExpressApp = {use: (fn: Use) => void, post: (route: string, callback: (req: ReqRefreshToken, res: ResRefreshToken) => void) => void}
+
+let app: ExpressApp
 
 
 
@@ -15,16 +25,15 @@ const DEPLOY_TOKEN_SECRET = process.env.DEPLOY_TOKEN_SECRET || "MY_SECRET_DEPLOY
 
 const NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN_SECRET = process.env.NDCURVE_DEVELOPER_LICENSE_ACCESS_TOKEN_PUBLIC_KEY
 
-let urlsAllowed = []
-export var ALLOWED_URLS = []
+let urlsAllowed: string[] = []
+export let ALLOWED_URLS: string[] = []
 
-export const start = (expressApp, allowedUrls) => {
+export const start = (expressApp: ExpressApp, allowedUrls: string[]) => {
     urlsAllowed = ["/refreshToken", "/login"].concat(allowedUrls ?? [])
     ALLOWED_URLS = urlsAllowed
     app = expressApp
 
-
-    app.use(async (req, res, next) => {
+    app.use(async (req: Req, res: Res, next: Next) => {
 
         // return next()    // Disable session
 
@@ -33,7 +42,7 @@ export const start = (expressApp, allowedUrls) => {
         if (urlsAllowed.includes(req.path))
             return next()
 
-        const checkPrivilege = async req => {
+        const checkPrivilege = async (req: Req) => {
             const staff = Utils.isEmpty(req.body.staff) ? 'BLANK_STAFF' : req.body.staff
             const granted = (await Features.send({company: req.body.company, outlet: req.body.outlet, app: req.body.app}, "privileges.query.check", {feature: req.body.feature }, {id: staff})).data.granted
             if (!granted)
@@ -71,11 +80,13 @@ export const start = (expressApp, allowedUrls) => {
                 return next()
             throw null;
         } catch (error) {
-            return res.status(401).json({ message: error?.message === "Access Denied" ? error.message : 'Unauthorized' })
+            type ErrorType = { message?: string }
+            res.status(401).json({ message: (error as ErrorType)?.message === "Access Denied" ? "Access Denied" : 'Unauthorized' })
         }
     })
 
-    app.post("/refreshToken", (req, res) => {
+
+    app.post("/refreshToken", (req: ReqRefreshToken, res: ResRefreshToken) => {
         try {
             let { userId, clientId, refreshToken } = req.body
             type Decoded = {userId: string, clientId: string}
@@ -101,7 +112,7 @@ export const start = (expressApp, allowedUrls) => {
 }
 
 
-export const generateAccessToken = (userId, clientId) => {
+export const generateAccessToken = (userId: string, clientId: string) => {
     let data = { userId, clientId }
 
     let now = Utils.now()

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "corebasic",
   "type": "module",
-  "version": "1.0.230",
+  "version": "1.0.232",
   "description": "",
   "main": "dist/index.js",
   "types": "./index.ts",