@ibertran/fortytwo-intra-client 4.1.0 → 5.0.0

package/README.md

@@ -20,6 +20,26 @@ const user = await client.get("users/ibertran");
 console.log(user);
 ```
 
+## Intra V3
+
+The library also exports `FortytwoIntraV3Client` for staff-only Intra V3 endpoints that use the 42 Auth token flow.
+
+```typescript
+import { FortytwoIntraV3Client } from "@ibertran/fortytwo-intra-client";
+
+const client = new FortytwoIntraV3Client({
+	client_id: "staff-42-campus",
+	client_secret: "your_client_secret",
+	username: "your_staff_login",
+	password: "your_staff_password",
+});
+
+const response = await client.get("some/v3/endpoint");
+console.log(response);
+```
+
+The V3 client automatically requests a bearer token, reuses it while valid, and falls back to the refresh token when available.
+
 ## Configuration
 
 The `FortytwoIntraClient` class accepts three parameters:

package/dist/errors/httpError.d.ts

@@ -0,0 +1,8 @@
+import { AxiosError } from "axios";
+export declare class FortytwoIntraClientHttpError extends Error {
+    statusCode: number;
+    statusText: string;
+    data: unknown;
+    constructor(error: AxiosError);
+}
+export declare function isFortytwoIntraClientHttpError(error: unknown): error is FortytwoIntraClientHttpError;

package/dist/errors/httpError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FortytwoIntraClientHttpError = void 0;
+exports.isFortytwoIntraClientHttpError = isFortytwoIntraClientHttpError;
+class FortytwoIntraClientHttpError extends Error {
+    statusCode;
+    statusText;
+    data;
+    constructor(error) {
+        const method = error.config?.method?.toUpperCase() ?? null;
+        const route = error.config?.url ?? null;
+        const statusCode = error.response?.status ?? NaN;
+        const statusText = error.response?.statusText ?? "Unknown";
+        const message = method && route ? `${method} ${route} - HTTP ${statusCode} ${statusText}` : error.message;
+        super(message);
+        this.name = "FortytwoIntraClientHttpError";
+        this.statusCode = statusCode;
+        this.statusText = statusText;
+        this.data = error.response?.data;
+    }
+}
+exports.FortytwoIntraClientHttpError = FortytwoIntraClientHttpError;
+function isFortytwoIntraClientHttpError(error) {
+    return error instanceof FortytwoIntraClientHttpError;
+}

package/dist/errors/validationError.js

@@ -6,11 +6,7 @@ class FortytwoIntraClientValidationError extends Error {
     schemaErrors;
     data;
     constructor(schemaErrors, data) {
-        // const errorMessages = schemaErrors.errors
-        // 	.map((error) => `${error.path.join(".")} - ${error.message}`)
-        // 	.join("; ");
-        const message = `Schema validation failed: `;
-        super(message);
+        super("Schema validation failed");
         this.name = "FortytwoIntraClientValidationError";
         this.schemaErrors = schemaErrors;
         this.data = data;

package/dist/index.d.ts

@@ -1,6 +1,8 @@
+import z from "zod";
 import { inputOptions } from "./types";
-import { FortytwoIntraClientError, isFortytwoIntraClientError } from "./lib/errors";
-import { z } from "zod";
+export { FortytwoIntraV3Client } from "./intraV3";
+export * from "./errors/httpError";
+export * from "./errors/validationError";
 export interface FortytwoIntraClientConf {
     redirect_uri: string | null;
     base_url: string;
@@ -73,4 +75,3 @@ export declare class FortytwoIntraClient {
     exchangeOAuthCode(code: string, redirect_uri?: string): Promise<any>;
     tokenInfos(options?: Omit<inputOptions, "body" | "perPage" | "maxPages">): Promise<any>;
 }
-export { FortytwoIntraClientError, isFortytwoIntraClientError };

package/dist/index.js

@@ -32,20 +32,25 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFortytwoIntraClientError = exports.FortytwoIntraClientError = exports.FortytwoIntraClient = void 0;
+exports.FortytwoIntraClient = exports.FortytwoIntraV3Client = void 0;
 const axios_1 = __importStar(require("axios"));
 const axios_rate_limit_1 = __importDefault(require("axios-rate-limit"));
-const pagination_1 = require("./lib/pagination");
+const zod_1 = __importDefault(require("zod"));
 const logs_1 = require("./lib/logs");
-const errors_1 = require("./lib/errors");
-Object.defineProperty(exports, "FortytwoIntraClientError", { enumerable: true, get: function () { return errors_1.FortytwoIntraClientError; } });
-Object.defineProperty(exports, "isFortytwoIntraClientError", { enumerable: true, get: function () { return errors_1.isFortytwoIntraClientError; } });
-const zod_1 = require("zod");
+const pagination_1 = require("./lib/pagination");
+const httpError_1 = require("./errors/httpError");
 const validationError_1 = require("./errors/validationError");
+var intraV3_1 = require("./intraV3");
+Object.defineProperty(exports, "FortytwoIntraV3Client", { enumerable: true, get: function () { return intraV3_1.FortytwoIntraV3Client; } });
+__exportStar(require("./errors/httpError"), exports);
+__exportStar(require("./errors/validationError"), exports);
 const defaultConf = {
     redirect_uri: null,
     base_url: "https://api.intra.42.fr/v2/",
@@ -156,7 +161,7 @@ class FortytwoIntraClient {
                     return this.reqHandler(url, options);
                 }
                 else {
-                    throw new errors_1.FortytwoIntraClientError(err);
+                    throw new httpError_1.FortytwoIntraClientHttpError(err);
                 }
             }
             else {
@@ -191,7 +196,7 @@ class FortytwoIntraClient {
             return schema.parse(data);
         }
         catch (err) {
-            if (err instanceof zod_1.z.ZodError) {
+            if (err instanceof zod_1.default.ZodError) {
                 throw new validationError_1.FortytwoIntraClientValidationError(err, data);
             }
             throw err;

package/dist/intraV3/index.d.ts

@@ -0,0 +1,58 @@
+import z from "zod";
+import { inputOptions } from "../types";
+export * from "../errors/httpError";
+export * from "../errors/validationError";
+export interface FortytwoIntraClientConf {
+    base_url: string | undefined;
+    token_url: string;
+    maxRetry: number;
+    logLine: boolean;
+    errLogBody: boolean;
+}
+type Credentials = {
+    client_id: string;
+    client_secret: string;
+    username: string;
+    password: string;
+};
+export declare class FortytwoIntraV3Client {
+    private credentials;
+    private base_url;
+    private token_url;
+    private axiosInstance;
+    private retryOn;
+    private maxRetry;
+    private logLine;
+    private errLogBody;
+    private authorization;
+    constructor(credentials: Credentials, conf?: Partial<FortytwoIntraClientConf>);
+    private generateToken;
+    private isTokenValid;
+    private isRefreshTokenValid;
+    private fetch;
+    private reqHandler;
+    private logSuccess;
+    private logError;
+    private validate;
+    get(endpoint: URL | string, options?: Omit<inputOptions, "body" | "perPage" | "maxPages" | "token">): Promise<any>;
+    get<S extends z.ZodType>(endpoint: URL | string, options: Omit<inputOptions, "body" | "perPage" | "maxPages" | "token"> & {
+        schema: S;
+    }): Promise<z.infer<S>>;
+    post(endpoint: URL | string, options?: Omit<inputOptions, "perPage" | "maxPages">): Promise<any>;
+    post<S extends z.ZodType>(endpoint: URL | string, options: Omit<inputOptions, "perPage" | "maxPages"> & {
+        schema: S;
+    }): Promise<z.infer<S>>;
+    put(endpoint: URL | string, options?: Omit<inputOptions, "perPage" | "maxPages">): Promise<any>;
+    put<S extends z.ZodType>(endpoint: URL | string, options: Omit<inputOptions, "perPage" | "maxPages"> & {
+        schema: S;
+    }): Promise<z.infer<S>>;
+    patch(endpoint: URL | string, options?: Omit<inputOptions, "perPage" | "maxPages">): Promise<any>;
+    patch<S extends z.ZodType>(endpoint: URL | string, options: Omit<inputOptions, "perPage" | "maxPages"> & {
+        schema: S;
+    }): Promise<z.infer<S>>;
+    delete(endpoint: URL | string, options?: Omit<inputOptions, "perPage" | "maxPages">): Promise<any>;
+    delete<S extends z.ZodType>(endpoint: URL | string, options: Omit<inputOptions, "perPage" | "maxPages"> & {
+        schema: S;
+    }): Promise<z.infer<S>>;
+    URL(endpoint: string): URL;
+}

package/dist/intraV3/index.js

@@ -0,0 +1,266 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FortytwoIntraV3Client = void 0;
+const axios_1 = __importStar(require("axios"));
+const zod_1 = __importDefault(require("zod"));
+const logs_1 = require("../lib/logs");
+const httpError_1 = require("../errors/httpError");
+const validationError_1 = require("../errors/validationError");
+const schemas_1 = require("./schemas");
+__exportStar(require("../errors/httpError"), exports);
+__exportStar(require("../errors/validationError"), exports);
+const defaultConf = {
+    base_url: undefined,
+    token_url: "https://auth.42.fr/auth/realms/staff-42/protocol/openid-connect/token",
+    maxRetry: 5,
+    logLine: true,
+    errLogBody: true,
+};
+class FortytwoIntraV3Client {
+    credentials;
+    base_url;
+    token_url;
+    axiosInstance;
+    retryOn;
+    maxRetry;
+    logLine;
+    errLogBody;
+    authorization;
+    constructor(credentials, conf = {}) {
+        this.credentials = credentials;
+        const config = { ...defaultConf, ...conf };
+        this.base_url = config.base_url;
+        this.token_url = config.token_url;
+        this.axiosInstance = axios_1.default.create();
+        this.retryOn = [401, 429, 500];
+        this.maxRetry = config.maxRetry;
+        this.logLine = config.logLine;
+        this.errLogBody = config.errLogBody;
+        this.authorization = null;
+    }
+    async generateToken() {
+        const data = this.authorization && this.isRefreshTokenValid()
+            ? new URLSearchParams({
+                grant_type: "refresh_token",
+                refresh_token: this.authorization.refresh_token,
+            })
+            : new URLSearchParams({
+                grant_type: "password",
+                username: this.credentials.username,
+                password: this.credentials.password,
+            });
+        const res = await this.axiosInstance.post(this.token_url, data, {
+            headers: {
+                Authorization: `Basic ${Buffer.from(`${this.credentials.client_id}:${this.credentials.client_secret}`).toString("base64")}`,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+        });
+        return schemas_1.tokenSchema.parse(res.data);
+    }
+    isTokenValid() {
+        return this.authorization !== null && this.authorization.expires_at - 30000 > Date.now();
+    }
+    isRefreshTokenValid() {
+        return (this.authorization !== null && this.authorization.refresh_expires_at - 30000 > Date.now());
+    }
+    async fetch(url, options) {
+        const { method, body, query } = options;
+        if (!this.isTokenValid()) {
+            this.authorization = await this.generateToken();
+        }
+        // Attach access_token
+        const accessToken = this.authorization?.access_token;
+        // Extract query parameters from URL and combine with options.query
+        const urlParams = {};
+        url.searchParams.forEach((value, key) => {
+            urlParams[key] = value;
+        });
+        // Combine URL params with query params (query params take precedence)
+        const combinedParams = { ...urlParams, ...query };
+        // Create clean URL without query parameters
+        const cleanUrl = new URL(url);
+        cleanUrl.search = "";
+        return this.axiosInstance.request({
+            method: method.toLowerCase(),
+            url: cleanUrl.toString(),
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            params: combinedParams,
+            data: body ? body : undefined,
+        });
+    }
+    async reqHandler(url, options) {
+        try {
+            const res = await this.fetch(url, options);
+            this.logSuccess(res, options);
+            return res;
+        }
+        catch (err) {
+            if ((0, axios_1.isAxiosError)(err)) {
+                this.logError(err, options);
+                const { attempt, maxRetry } = options;
+                const status = err.response?.status;
+                if (maxRetry > 0 && attempt < maxRetry && status && this.retryOn.includes(status)) {
+                    if (status === 401) {
+                        this.authorization = null;
+                    }
+                    options.attempt++;
+                    return this.reqHandler(url, options);
+                }
+                else {
+                    throw new httpError_1.FortytwoIntraClientHttpError(err);
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    logSuccess(res, options) {
+        if (!options.logLine)
+            return;
+        const line = (0, logs_1.getLogLine)(res, options);
+        console.log(line);
+    }
+    logError(err, options) {
+        if (!options.logLine)
+            return;
+        const line = (0, logs_1.getErrorLogLine)(err, options);
+        const body = err.response?.data;
+        const logBody = options.errLogBody && body && Object.keys(body).length;
+        try {
+            console.log(line, logBody ? JSON.stringify(body, null, 2) : "");
+        }
+        catch {
+            console.log(line, logBody ? body : "");
+        }
+    }
+    validate(data, schema) {
+        if (!schema) {
+            return data;
+        }
+        try {
+            return schema.parse(data);
+        }
+        catch (err) {
+            if (err instanceof zod_1.default.ZodError) {
+                throw new validationError_1.FortytwoIntraClientValidationError(err, data);
+            }
+            throw err;
+        }
+    }
+    async get(endpoint, options = {}) {
+        if (endpoint instanceof URL === false) {
+            endpoint = new URL(endpoint, this.base_url);
+        }
+        const res = await this.reqHandler(endpoint, {
+            method: "GET",
+            attempt: 0,
+            maxRetry: this.maxRetry,
+            logLine: this.logLine,
+            errLogBody: this.errLogBody,
+            ...options,
+        });
+        return this.validate(res.data, options.schema);
+    }
+    async post(endpoint, options = {}) {
+        if (endpoint instanceof URL === false) {
+            endpoint = new URL(endpoint, this.base_url);
+        }
+        const res = await this.reqHandler(endpoint, {
+            method: "POST",
+            attempt: 0,
+            maxRetry: this.maxRetry,
+            logLine: this.logLine,
+            errLogBody: this.errLogBody,
+            ...options,
+        });
+        return this.validate(res.data, options.schema);
+    }
+    async put(endpoint, options = {}) {
+        if (endpoint instanceof URL === false) {
+            endpoint = new URL(endpoint, this.base_url);
+        }
+        const res = await this.reqHandler(endpoint, {
+            method: "PUT",
+            attempt: 0,
+            maxRetry: this.maxRetry,
+            logLine: this.logLine,
+            errLogBody: this.errLogBody,
+            ...options,
+        });
+        return this.validate(res.data, options.schema);
+    }
+    async patch(endpoint, options = {}) {
+        if (endpoint instanceof URL === false) {
+            endpoint = new URL(endpoint, this.base_url);
+        }
+        const res = await this.reqHandler(endpoint, {
+            method: "PATCH",
+            attempt: 0,
+            maxRetry: this.maxRetry,
+            logLine: this.logLine,
+            errLogBody: this.errLogBody,
+            ...options,
+        });
+        return this.validate(res.data, options.schema);
+    }
+    async delete(endpoint, options = {}) {
+        if (endpoint instanceof URL === false) {
+            endpoint = new URL(endpoint, this.base_url);
+        }
+        const res = await this.reqHandler(endpoint, {
+            method: "DELETE",
+            attempt: 0,
+            maxRetry: this.maxRetry,
+            logLine: this.logLine,
+            errLogBody: this.errLogBody,
+            ...options,
+        });
+        return this.validate(res.data, options.schema);
+    }
+    URL(endpoint) {
+        return new URL(endpoint, this.base_url);
+    }
+}
+exports.FortytwoIntraV3Client = FortytwoIntraV3Client;

package/dist/intraV3/schemas.d.ts

@@ -0,0 +1,27 @@
+import z from "zod";
+export declare const tokenSchema: z.ZodPipe<z.ZodObject<{
+    access_token: z.ZodString;
+    expires_in: z.ZodNumber;
+    refresh_expires_in: z.ZodNumber;
+    refresh_token: z.ZodString;
+    token_type: z.ZodString;
+    "not-before-policy": z.ZodNumber;
+    session_state: z.ZodString;
+    scope: z.ZodString;
+}, z.core.$strict>, z.ZodTransform<{
+    access_token: string;
+    expires_at: number;
+    refresh_token: string;
+    refresh_expires_at: number;
+    token_type: string;
+}, {
+    access_token: string;
+    expires_in: number;
+    refresh_expires_in: number;
+    refresh_token: string;
+    token_type: string;
+    "not-before-policy": number;
+    session_state: string;
+    scope: string;
+}>>;
+export type Token = z.infer<typeof tokenSchema>;

package/dist/intraV3/schemas.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.tokenSchema = zod_1.default
+    .strictObject({
+    access_token: zod_1.default.string(),
+    expires_in: zod_1.default.number(),
+    refresh_expires_in: zod_1.default.number(),
+    refresh_token: zod_1.default.string(),
+    token_type: zod_1.default.string(),
+    "not-before-policy": zod_1.default.number(),
+    session_state: zod_1.default.string(),
+    scope: zod_1.default.string(),
+})
+    .transform((obj) => {
+    const now = Date.now();
+    return {
+        access_token: obj.access_token,
+        expires_at: now + obj.expires_in * 1000,
+        refresh_token: obj.refresh_token,
+        refresh_expires_at: now + obj.refresh_expires_in * 1000,
+        token_type: obj.token_type,
+    };
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ibertran/fortytwo-intra-client",
-	"version": "4.1.0",
+	"version": "5.0.0",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
 	"author": {