@occupop/lib-auth 1.0.0

package/README.md

@@ -0,0 +1,149 @@
+# Package @occupop/lib-auth
+
+This package is intended to be used with `@occupop/lib-container`
+providing context function for GraphQL (or Express middleware) where AuthUser (or ScopedUser)
+gets validated and signed to container.
+
+This implementation refers to
+https://www.apollographql.com/docs/apollo-server/data/context!
+
+### *NPM registry token required!*
+
+## Install
+```bash
+# Yarn
+yarn add @occupop/lib-auth
+
+# NPM
+npm install @occupop/lib-auth
+
+# Bun
+bun add @occupop/lib-auth
+```
+
+## Env Setup
+ENV variables required
+```dotenv
+JWT_SECRET=randomTokenProvidedByAuthService
+```
+
+## Register
+
+```typescript
+import {
+    makeGraphqlServer, graphqlMiddleware, graphqlStandalone
+} from '@occupop/lib-graphql'
+import { resolvers } from './app/resolvers'
+//... all other imports omited... 
+
+export const container = createTypedContainer({
+    container: { asFunction: () => container, singleton: true },
+    // ...
+    // for graphql:
+    authContextValueFunction: { asFunction: makeAuthContextValueFunction, singleton: true },
+    // for express:
+    authContextMiddleware: { asFunction: makeAuthContextMiddleware, singleton: true },
+    // ...
+})
+
+```
+**Note:** container need to be self registered/referenced to be possible to context function/middleware register
+AuthUser and ScopedUser, that is extracted from request headers.
+
+## Usage (with graphql)
+
+```typescript
+// server.ts
+import { container } from '.container'
+
+const { mongoClient, graphqlServer, graphqlStandalone, authContextValueFunction } = container.cradle
+
+await mongoClient.connect()
+console.log('Mongo connected')
+
+const httpPort = process.env.API_PORT || 4000
+await await graphqlStandalone(graphqlServer, {
+  context: authContextValueFunction,
+  listen: { port: httpPort },
+})
+console.log(`Server listening on http://localhost:${httpPort}`)
+```
+
+```typescript
+// app/resolvers.ts
+import { container } from '.container'
+
+export const resolvers: GraphQLResolverMap<{ container: typeof container}> = {
+  Query: {
+    jobs: (source, { skip, take }, { container }, info) => {
+      const { getJobsUseCase } = container.cradle
+      return getJobsUseCase(skip, take)
+    },
+  },
+}
+```
+
+```typescript
+// app/use-cases/get-jobs-use-case.ts
+import { type Deps } from '.container'
+
+export function makeGetJobsUseCase({ authUser, jobService }: Deps) {
+  return (skip = 0, take = 15) => {
+    if (!authUser?.hiringCompanyUuid) throw 'not logged'
+    if (take > 100) take = 100
+    return jobService.getJobs(authUser.hiringCompanyUuid, skip, take)
+  }
+}
+```
+
+
+
+
+## Usage (with express)
+
+```typescript
+// server.ts
+import { container } from '.container'
+
+const { mongoClient, httpServer, appRouter, authContextMiddleware } = container.cradle
+
+await mongoClient.connect()
+console.log('Mongo connected')
+
+const httpPort = process.env.API_PORT || 4000
+httpServer.use(authContextMiddleware)
+httpServer.use(appRouter)
+await httpServer.listen(httpPort, () => {
+    console.log(`Http listening on http://localhost:${httpPort}`)
+})
+// ...
+```
+
+```typescript
+// app/router.ts
+export function makeAppRouter({ httpRouter }: Deps) {
+    return httpRouter
+        //...
+        .get('/jobs', (req, res) => {
+            const { getJobsUseCase } = req.container.cradle
+            res.json(getJobsUseCase(req.query.skip, req.query.take))
+        })
+        //...
+}
+```
+
+```typescript
+// app/use-cases/get-jobs-use-case.ts
+import { type Deps } from '.container'
+
+export function makeGetJobsUseCase({ authUser, jobService }: Deps) {
+    return (skip = 0, take = 15) => {
+        if (!authUser?.hiringCompanyUuid) throw 'not logged'
+        if (take > 100) take = 100
+        return jobService.getJobs(authUser.hiringCompanyUuid, skip, take)
+    }
+}
+```
+
+
+

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+import type { IncomingMessage, OutgoingMessage } from 'node:http';
+import { type AwilixContainer } from '@occupop/lib-container';
+type Request = IncomingMessage & {
+    container?: AwilixContainer;
+};
+type Response = OutgoingMessage;
+export type AuthUser = {
+    readonly userUuid: string;
+    readonly hiringCompanyUuid?: string;
+    readonly recruitmentAgencyUuid?: string;
+    readonly sysAdmin?: boolean;
+    readonly isAdmin?: boolean;
+    readonly isSuperAdmin?: boolean;
+};
+export type ScopedUser = {
+    readonly userUuid?: undefined;
+    readonly [entityUuid: string]: {
+        allowedFields: string[];
+    } | undefined;
+};
+export declare function getAuthUser(req: Request): AuthUser | null;
+export declare function getScopedUser(req: Request): ScopedUser | null;
+export declare function makeAuthContextValueFunction<IContainer extends AwilixContainer>({ container }: {
+    container: IContainer;
+}): (req: Request, res: Response) => {
+    container: AwilixContainer<any>;
+};
+export declare function makeAuthContextMiddlewareFunction<IContainer extends AwilixContainer>({ container }: {
+    container: IContainer;
+}): (req: Request, res: Response) => void;
+export {};

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAuthUser = getAuthUser;
+exports.getScopedUser = getScopedUser;
+exports.makeAuthContextValueFunction = makeAuthContextValueFunction;
+exports.makeAuthContextMiddlewareFunction = makeAuthContextMiddlewareFunction;
+const lib_container_1 = require("@occupop/lib-container");
+const jsonwebtoken_1 = require("jsonwebtoken");
+function getToken(req) {
+    var _a;
+    return (_a = req.headers.authorization) === null || _a === void 0 ? void 0 : _a.replace(/^Bearer /, '');
+}
+function checkToken(token) {
+    if (!token)
+        return null;
+    if (!process.env.JWT_SECRET)
+        throw 'Env var JWT_SECRET not set?';
+    try {
+        return (0, jsonwebtoken_1.verify)(token, process.env.JWT_SECRET);
+    }
+    catch (e) {
+        return null;
+    }
+}
+function getUserPayload(req) {
+    const token = getToken(req);
+    return checkToken(token);
+}
+function getAuthUser(req) {
+    const user = getUserPayload(req);
+    if (user === null || user === void 0 ? void 0 : user.userUuid)
+        return user;
+    return null;
+}
+function getScopedUser(req) {
+    const user = getUserPayload(req);
+    if (user && user.userUuid === undefined)
+        return user;
+    return null;
+}
+function makeAuthContextValueFunction({ container }) {
+    return (req, res) => {
+        const authUser = getAuthUser(req);
+        const scopedUser = getScopedUser(req);
+        const scopedContainer = container.createScope();
+        if (authUser)
+            container.register('authUser', (0, lib_container_1.asValue)(authUser));
+        if (scopedUser)
+            container.register('scopedUser', (0, lib_container_1.asValue)(scopedUser));
+        return { container: scopedContainer };
+    };
+}
+function makeAuthContextMiddlewareFunction({ container }) {
+    return (req, res) => {
+        const authContextValueFunction = makeAuthContextValueFunction({ container });
+        const contextValue = authContextValueFunction(req, res);
+        req.container = contextValue.container;
+    };
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@occupop/lib-auth",
+  "version": "1.0.0",
+  "main": "dist/index.js",
+  "module": "index.ts",
+  "description": "...",
+  "files": ["dist", "README.md"],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "bun test",
+    "cover": "bun test --coverage",
+    "lint": "biome lint",
+    "dist": "bun lint && bun cover && rm -fr dist && tsc"
+  },
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "jsonwebtoken": "^9.0.2"
+  },
+  "peerDependencies": {
+    "@occupop/lib-container": "^1.1.0",
+    "typescript": "^5.6.3"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/bun": "latest",
+    "@types/jsonwebtoken": "^9.0.7"
+  }
+}