test(@sirutils/wizard): middleware

Author: siaeyy

packages/wizard/test-middleware/app.ts

@@ -0,0 +1,4 @@
+import './handler'
+import './middlewares/auth'
+import './services/users'
+import './wizard'

packages/wizard/test-middleware/consts.ts

@@ -0,0 +1,21 @@
+import { extractEnvs } from '@sirutils/core'
+
+export const ENV = extractEnvs<
+  Sirutils.DriverScylla.Env &
+    Sirutils.DriverRedis.Env & {
+      mode: Exclude<Sirutils.Wizard.Options['environment'], undefined>
+    }
+>(env => ({
+  scyllaContactPoints: env.SCYLLA_CONTACT_POINTS?.split(','),
+  scyllaLocalDataCenter: env.SCYLLA_LOCAL_DATA_CENTER,
+  scyllaPassword: env.SCYLLA_PASSWORD,
+  scyllaUsername: env.SCYLLA_USERNAME,
+
+  redisHost: env.REDIS_HOST,
+  redisPort: env.REDIS_PORT,
+  redisPassword: env.REDIS_PASSWORD,
+  redisUsername: env.REDIS_USERNAME,
+  redisDatabase: env.REDIS_DATABASE || '0',
+
+  mode: env.NODE_ENV || 'development',
+}))

packages/wizard/test-middleware/drivers.ts

@@ -0,0 +1,25 @@
+import { createRedisDriver } from '@sirutils/driver-redis'
+import { createScyllaDriver } from '@sirutils/driver-scylla'
+
+import { ENV } from './consts'
+
+export const redis = await createRedisDriver({
+  client: {
+    host: ENV.redisHost,
+    port: ENV.redisPort,
+    db: ENV.redisDatabase,
+    password: ENV.redisPassword,
+  },
+})
+
+export const scylla = await createScyllaDriver(
+  {
+    client: {
+      contactPoints: ENV.scyllaContactPoints,
+      localDataCenter: ENV.scyllaLocalDataCenter,
+      credentials: { username: ENV.scyllaUsername, password: ENV.scyllaPassword },
+      keyspace: 'sirius',
+    },
+  },
+  redis
+)

packages/wizard/test-middleware/handler.ts

@@ -0,0 +1,23 @@
+import { ProjectError } from '@sirutils/core'
+
+import { logger } from '../src/internal/logger'
+
+process
+  .on('unhandledRejection', (_reason, p) => {
+    if (p instanceof ProjectError) {
+      p.appendCause('?handler')
+      logger.error(p.stringify())
+    } else {
+      logger.error(p)
+    }
+  })
+  .on('uncaughtException', err => {
+    if (err instanceof ProjectError) {
+      err.appendCause('?handler')
+      logger.error(err.stringify())
+    } else {
+      logger.error(err)
+    }
+
+    process.exit(1)
+  })

packages/wizard/test-middleware/middlewares/auth.ts

@@ -0,0 +1,46 @@
+import { wizard } from '../wizard'
+
+export const auth = wizard.api.createMiddleware(
+    {
+        name: 'auth',
+        share: ['user']
+    },
+    (ctx, next) => {
+        if(ctx.req && ctx.res) {
+            const authHeader = ctx.req.headers.authorization
+            //biome-ignore lint/complexity/useOptionalChain: <explanation>
+            const token = authHeader && authHeader.split(" ")[1]
+
+            if (token !== undefined) {
+                ctx.share.user = {
+                    name: "siaeyy"
+                }
+                return next
+            }
+
+            ctx.res.statusCode = 404
+            ctx.res.end("Authorization is not found!")
+            return 
+        }
+        
+        return undefined
+    }
+)
+
+declare global {
+    //biome-ignore lint/style/noNamespace: <explanation>
+    namespace Sirutils {
+        //biome-ignore lint/style/noNamespace: <explanation>
+        namespace Wizard {
+            interface ContextShare {
+                'user': {
+                    name: string
+                }
+            }
+        }
+
+        interface WizardMiddlewares {
+            'auth': typeof auth
+        }
+    }
+}

packages/wizard/test-middleware/services/users.ts

@@ -0,0 +1,31 @@
+import { wizard } from '../wizard'
+
+const usersService = await wizard.api.service({
+  name: 'users',
+  version: '0.0.1',
+  description: 'users api',
+
+  actions: {
+    get: wizard.api.createAction(
+      {
+        rest: 'GET /',
+        middlewares: ['auth']
+      },
+      ctx => {
+        //biome-ignore lint/suspicious/noConsole: <explanation>
+        console.log(ctx.share?.user)
+
+        return JSON.stringify(ctx.share?.user)
+      }
+    ),
+  },
+})
+
+declare global {
+  // biome-ignore lint/style/noNamespace: <explanation>
+  namespace Sirutils {
+    interface WizardServices {
+      'users@0.1.1': typeof usersService
+    }
+  }
+}

packages/wizard/test-middleware/wizard.ts

@@ -0,0 +1,11 @@
+import { createWizard } from '../src'
+import { ENV } from './consts'
+import { redis, scylla } from './drivers'
+
+export const wizard = await createWizard(
+  {
+    environment: ENV.mode,
+  },
+  redis,
+  scylla
+)