@eduzz/miau-client 0.0.11 → 0.0.13

package/dist/miau-types/types/Application.d.ts

@@ -1,7 +1,7 @@
 import { type Resource } from './Resource';
 import { type Secret } from './Secret';
 export type Application = {
-    id: string;
+    id?: string;
     organizationId: string;
     name: string;
     slug: string;

package/dist/miau-types/types/Permission.d.ts

@@ -1,6 +1,6 @@
 import { type Resource } from './Resource';
 export type Permission = {
-    id: string;
+    id?: string;
     organizationId: string;
     sourceAppId: string;
     targetAppId: string;

package/dist/miau-types/types/Resource.d.ts

@@ -3,7 +3,7 @@ export declare const ResourceTypes: ResourceType[];
 export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
 export declare const HttpMethods: HttpMethod[];
 export type Resource = {
-    id: string;
+    id?: string;
     type: ResourceType;
     method: HttpMethod;
     path: string;

package/dist/middleware.d.ts

@@ -0,0 +1,9 @@
+import { type RequestHandler, type NextFunction, type Request, type Response } from 'express';
+import type { MiauApplication } from '@eduzz/miau-types';
+import type { MiauClient } from './MiauClient';
+export type RequestAugmentation<T> = (data: {
+    req: Request;
+    app: MiauApplication;
+    meta: T;
+}) => void;
+export declare const miauMiddleware: <T>(miauClient: MiauClient, requestAugmentation?: RequestAugmentation<T>, fallbackMidlleware?: RequestHandler) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eduzz/miau-client",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "Eduzz Miau Client",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/src/MiauClient.ts

@@ -1,13 +1,12 @@
+import { type RequestHandler } from 'express';
 import jwt from 'jsonwebtoken';
 import { JwksClient } from 'jwks-rsa';
 
 import { type Permission } from '@eduzz/miau-types';
 
-type MiauClientConfig = {
-  apiUrl: string;
-  appSecret: string;
-};
+import { miauMiddleware, type RequestAugmentation } from './middleware';
 
+type MiauClientConfig = { apiUrl: string; appSecret: string };
 type FetchInput = Parameters<typeof fetch>[0];
 type FetchInit = Parameters<typeof fetch>[1];
 
@@ -72,6 +71,13 @@ export class MiauClient {
     return this.jwtToken;
   }
 
+  public middleware<T = Record<string, string>>(
+    requestAugmentation?: RequestAugmentation<T>,
+    fallbackMidlleware?: RequestHandler
+  ): RequestHandler {
+    return miauMiddleware<T>(this, requestAugmentation, fallbackMidlleware);
+  }
+
   public async getPermissions(targetAppId: string) {
     if (this.permissionsCache.has(targetAppId)) {
       const { data, expiresAt } = this.permissionsCache.get(targetAppId)!;

package/src/index.ts

@@ -1,3 +1,2 @@
 export * from '@eduzz/miau-types';
 export * from './MiauClient';
-export * from './MiauMiddleware';

package/src/middleware.ts

@@ -0,0 +1,93 @@
+import { type RequestHandler, type NextFunction, type Request, type Response } from 'express';
+import jwt from 'jsonwebtoken';
+
+import type { MiauApplication, Resource } from '@eduzz/miau-types';
+
+import type { MiauClient } from './MiauClient';
+
+class HttpError extends Error {
+  public status: number;
+
+  constructor(status: number, name: string, message: string) {
+    super(message);
+    this.name = name;
+    this.status = status;
+
+    Object.setPrototypeOf(this, HttpError.prototype);
+  }
+}
+
+export type RequestAugmentation<T> = (data: { req: Request; app: MiauApplication; meta: T }) => void;
+
+const wildcardToRegex = (pattern: string) => {
+  const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&');
+  const withWildcards = escaped.replace(/\*/g, '[^/]+');
+  const regexStr = `^${withWildcards}$`;
+  return new RegExp(regexStr);
+};
+
+export const miauMiddleware = <T>(
+  miauClient: MiauClient,
+  requestAugmentation?: RequestAugmentation<T>,
+  fallbackMidlleware?: RequestHandler
+) => {
+  return async (req: Request, res: Response, next: NextFunction) => {
+    try {
+      const token = req.headers.authorization?.split(' ').pop();
+
+      if (!token) {
+        throw new HttpError(401, 'Invalid Token', 'Token not provided');
+      }
+
+      const decodedToken = jwt.decode(token, { complete: true }) as { header: { kid: string } };
+
+      if (!decodedToken?.header?.kid) {
+        throw new HttpError(401, 'Invalid Token', 'Missing kid in token header');
+      }
+
+      const publicKey = await miauClient.getPublicKey(decodedToken.header.kid);
+      const appToken = jwt.verify(token, publicKey, { algorithms: ['RS256'] }) as MiauApplication;
+
+      if (!appToken || !appToken.id || !appToken.name) {
+        throw new HttpError(401, 'Invalid Token', 'Token verification failed');
+      }
+
+      const permission = await miauClient.getPermissions(appToken.id);
+
+      if (!permission) {
+        res.status(401).json({ error: 'Unauthorized', message: 'No permissions found for this application' });
+      }
+
+      const resources = permission?.resources || [];
+      const isAllowed = resources.some((resource: Resource) => {
+        return (
+          resource.method.toLowerCase() === req.method.toLowerCase() &&
+          wildcardToRegex(resource.path).test(req.path.toLowerCase())
+        );
+      });
+
+      if (!isAllowed) {
+        throw new HttpError(403, 'Forbidden', `You do not have permission to access ${req.method} ${req.path}`);
+      }
+
+      req.miauApplication = { id: appToken?.id, name: appToken?.name };
+      req.miauMetadata = permission?.metadata || {};
+
+      if (requestAugmentation) {
+        console.log('Request augmentation is being applied');
+        requestAugmentation({ req, app: req.miauApplication, meta: req.miauMetadata as T });
+      }
+
+      next();
+    } catch (err: HttpError | any) {
+      if (err instanceof HttpError && err.status == 401 && fallbackMidlleware) {
+        return fallbackMidlleware(req, res, next);
+      }
+
+      const errorStatus = err.status || 403;
+
+      res.status(errorStatus).json({ error: err.name, message: err.message });
+      return;
+    }
+  };
+};

package/dist/MiauMiddleware.d.ts

@@ -1,3 +0,0 @@
-import { type NextFunction, type Request, type Response } from 'express';
-import type { MiauClient } from './MiauClient';
-export declare const miauMiddleware: (miauService: MiauClient) => (req: Request, res: Response, next: NextFunction) => Promise<void>;

package/src/MiauMiddleware.ts

@@ -1,61 +0,0 @@
-import { type NextFunction, type Request, type Response } from 'express';
-import jwt from 'jsonwebtoken';
-
-import type { MiauApplication, Resource } from '@eduzz/miau-types';
-
-import type { MiauClient } from './MiauClient';
-
-const wildcardToRegex = (pattern: string) => {
-  const escaped = pattern.replace(/[-/\\^$+?.()|[\]{}]/g, '\\$&');
-  const withWildcards = escaped.replace(/\*/g, '[^/]+');
-  const regexStr = `^${withWildcards}$`;
-  return new RegExp(regexStr);
-};
-
-export const miauMiddleware = (miauService: MiauClient) => {
-  return async (req: Request, res: Response, next: NextFunction) => {
-    try {
-      const token = req.headers.authorization?.split(' ').pop();
-
-      if (!token) {
-        res.status(401).json({ error: 'Invalid Token', message: 'Token not provided' });
-        return;
-      }
-
-      const decodedToken = jwt.decode(token, { complete: true }) as { header: { kid: string } };
-
-      if (!decodedToken?.header?.kid) {
-        res.status(401).json({ error: 'Invalid token', message: 'Missing kid' });
-        return;
-      }
-
-      const publicKey = await miauService.getPublicKey(decodedToken.header.kid);
-      const appToken = jwt.verify(token, publicKey, { algorithms: ['RS256'] }) as MiauApplication;
-
-      req.miauApplication = { id: appToken?.id, name: appToken?.name };
-
-      const permission = await miauService.getPermissions(req.miauApplication.id);
-      req.miauMetadata = permission?.metadata || {};
-
-      const resources = permission?.resources || [];
-      const isAllowed = resources.some((resource: Resource) => {
-        return (
-          resource.method.toLowerCase() === req.method.toLowerCase() &&
-          wildcardToRegex(resource.path).test(req.path.toLowerCase())
-        );
-      });
-
-      if (!isAllowed) {
-        res
-          .status(403)
-          .json({ error: 'Forbidden', message: `You do not have permission to access ${req.method} ${req.path}` });
-        return;
-      }
-
-      next();
-    } catch (err: any) {
-      res.status(401).json({ error: err.name, message: err.message });
-      return;
-    }
-  };
-};