corebasic 1.0.229 → 1.0.231

package/libs/kafka.ts

@@ -4,12 +4,73 @@ import { Kafka, logLevel as KafkaLogLevel, CompressionTypes as KafkaCompressionT
 export const logLevel = KafkaLogLevel
 export const CompressionTypes = KafkaCompressionTypes
 
-let kafka, producer, admin
 
-let appName
+type KafkaCallback = (topic: string, message: unknown, partition: number) => unknown | Promise<unknown>
+
+type KafkaConsumer = {
+    connect: () => Promise<void>
+    subscribe: (arg: {topic: string; fromBeginning: boolean}) => Promise<void>
+    run: (arg: {
+        autoCommit: boolean
+        eachMessage: (arg: {
+            topic: string
+            partition: number
+            message: {
+                value: string | Buffer | null
+                offset: string
+            }
+        }) => Promise<void>
+    }) => Promise<void>
+    commitOffsets: (offsets: {topic: string; partition: number; offset: string}[]) => Promise<void>
+}
+
+type KafkaProducer = {
+    connect: () => Promise<void>
+    send: (arg: unknown) => Promise<unknown>
+}
+
+type KafkaAdmin = {
+    createTopics: (arg: {
+        topics: {
+            topic: string
+            numPartitions: number
+            replicationFactor: number
+        }[]
+    }) => Promise<unknown>
+}
+
+type KafkaClient = {
+    consumer: (arg: {groupId: string}) => KafkaConsumer
+    producer: (arg: {allowAutoTopicCreation: boolean}) => KafkaProducer
+    admin: () => KafkaAdmin
+}
+
+type KafkaStartArg = {
+    clientId?: string
+    brokers?: string[]
+    sasl?: false | {
+        mechanism: string
+        username?: string
+        password?: string
+    }
+    logLevel?: unknown
+}
+
+
+let kafka: KafkaClient
+let producer: KafkaProducer
+let admin: KafkaAdmin
+
+let appName: string
 let topicPrefix = ''
 
-export const start = (arg) => {
+declare global {
+    var app: {
+        name?: string
+    } | undefined
+}
+
+export const start = (arg?: KafkaStartArg) => {
     arg = !arg && !process.env.APP_DEPLOYMENT_NAME ? { clientId: (global.app?.name ?? 'app') + '-dev', brokers: ['127.0.0.1:9092'], sasl: false, logLevel: logLevel.ERROR } : arg
     appName = arg?.clientId ?? (process.env.APP_DEPLOYMENT_NAME ?? (global.app?.name ?? 'app'))
     topicPrefix = `${appName}.`
@@ -28,7 +89,7 @@ export const start = (arg) => {
 }
 
 
-export const createTopic = async (topic, partition, replicas) => {
+export const createTopic = async (topic: string, partition?: number, replicas?: number) => {
     topic = topicPrefix + topic
     return await admin.createTopics({ topics: [{topic, numPartitions: partition ?? 1, replicationFactor: replicas ?? 1}] })
 }
@@ -39,7 +100,7 @@ export const createTopic = async (topic, partition, replicas) => {
 
 let consumers = []
 
-const start_consumer = async function (topic, groupId, callback?: Function) {
+const start_consumer = async function (topic: string, groupId: string | KafkaCallback, callback?: KafkaCallback) {
     callback = typeof groupId === "string" ? callback : groupId
     groupId = typeof groupId === "string" ? `${appName}.${groupId}` : `${appName}.${topic}`
 
@@ -49,15 +110,17 @@ const start_consumer = async function (topic, groupId, callback?: Function) {
     await consumer.connect()
     await consumer.subscribe({ topic: topic, fromBeginning: true })
 
+    const fn = callback!
+
     await consumer.run({
         autoCommit: false,
         eachMessage: async ({ topic, partition, message }) => {
-            // callback(topic, message.value.toString(), partition) // toString() returns array so won't parse if json.
+            // fn(topic, message.value.toString(), partition) // toString() returns array so won't parse if json.
             let success
             try {
-                success = await callback(topic, JSON.parse(message.value), partition)
+                success = await fn(topic, JSON.parse(message.value as string), partition)
             } catch (ex) {
-                success = await callback(topic, message.value, partition)
+                success = await fn(topic, message.value, partition)
             }
 
             await consumer.commitOffsets([{ topic, partition, offset: (Number(message.offset) + 1).toString() }]);
@@ -71,7 +134,7 @@ const start_consumer = async function (topic, groupId, callback?: Function) {
 // Producer
 // ===========
 let producerInvoked = false
-const start_producer = async function (topic, message, key, options) {
+const start_producer = async function (topic: string, message: object, key: string, options?: object) {
 
     let isJson = Object.prototype.toString.call(message) === '[object Object]' || Object.prototype.toString.call(message) === '[object Array]'
 
@@ -97,13 +160,13 @@ const start_producer = async function (topic, message, key, options) {
 // start_consumer('quickstart-events')
 // start_producer('quickstart-events', 'Hello KafkaJS user! Little')
 
-export const receive = async function(topic, groupId, callback?: Function) {
+export const receive = async function(topic: string, groupId: string, callback?: KafkaCallback) {
     topic = topicPrefix + topic
     return (await start_consumer(topic, groupId, callback))
 }
 
 
-export const send = async function(topic, message, key, options) {
+export const send = async function(topic: string, message: object, key: string, options?: object) {
     topic = topicPrefix + topic
     await start_producer(topic, message, key, options)
 }

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
+}
+
+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/libs/utils.ts

@@ -124,7 +124,7 @@ export function toDate(arg: string, currentTime?: boolean): Date | undefined { /
 
 
 export function getDatesBetweenTwoDates(start: number | Date, end: number | Date) {
-    let arr = [];
+    let arr: Date[] = [];
     let dt = new Date(start);
 
 	dt.setHours(0)

package/package.json

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