@ibertran/fortytwo-intra-client 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ibertran
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,264 @@
+# FortytwoIntraClient
+
+A TypeScript library for interacting with the 42API with built-in rate limiting, automatic token management, and retry logic.
+
+## Installation
+
+```bash
+npm install @ibertran/fortytwo-intra-client
+```
+
+## Quick Start
+
+```typescript
+import { FortytwoIntraClient } from '@ibertran/fortytwo-intra-client';
+
+const client = new FortytwoIntraClient('your_client_id', 'your_client_secret');
+
+
+// Get a specific user by login
+const user = await client.get('users/jdoe');
+console.log(user);
+```
+
+## Configuration
+
+The `FortytwoIntraClient` class accepts three parameters:
+
+1. `client_id` (required): Your 42 API client ID
+2. `client_secret` (required): Your 42 API client secret  
+3. `config` (optional): Configuration object
+
+### Configuration Options
+
+```typescript
+interface Conf {
+  redirect_uri: string | null;      // OAuth redirect URI (default: null)
+  base_url: string;                 // API base URL (default: "https://api.intra.42.fr/v2/")
+  token_url: string;                // Token endpoint (default: "https://api.intra.42.fr/oauth/token")
+  oauth_url: string;                // OAuth endpoint (default: "https://api.intra.42.fr/oauth/authorize")
+  scopes: string[];                 // OAuth scopes (default: ["public"])
+  rate: number;                     // Requests per second (default: 2)
+  maxRetry: number;                 // Max retry attempts (default: 5)
+  logs: boolean;                    // Enable logging (default: true)
+  errors: boolean;                  // Enable error logging (default: true)
+}
+```
+
+### Example with Custom Configuration
+
+```typescript
+const client = new FortytwoIntraClient('your_client_id', 'your_client_secret', {
+  rate: 1,                        // 1 request per second
+  maxRetry: 3,                    // Retry up to 3 times
+  logs: false,                    // Disable logging
+  scopes: ['public', 'projects']  // Extended scopes
+});
+```
+
+## API Methods
+
+### GET Requests
+
+```typescript
+// Get all campuses
+const campuses = await client.get('campus');
+console.log(`Found ${campuses.length} campuses`);
+
+// Get a specific campus
+const lyonCampus = await client.get('campus/9');
+console.log(`${lyonCampus.name}: ${lyonCampus.users_count} users`);
+```
+
+### POST Requests
+
+```typescript
+// Create a team for a project
+const team = await client.post('teams', {
+  body: {
+    name: 'awesome-team',
+    project_id: 42
+  }
+});
+```
+
+### PATCH Requests
+
+```typescript
+// Update a team name
+const updatedTeam = await client.patch('teams/123', {
+  body: {
+		team: {
+			name: "updated-team-name"
+		}
+  }
+});
+```
+
+### DELETE Requests
+
+```typescript
+// Delete a team
+await client.delete('teams/123');
+```
+
+### Get All Pages (Pagination Helper)
+
+The `getAll` method automatically handles pagination and returns all results:
+
+```typescript
+// Get all users from 42 Lyon (handles pagination automatically)
+const lyonUsers = await client.getAll('campus/9/users');
+console.log(`Paris campus has ${lyonUsers.length} users`);
+
+// Get all projects with custom page size
+const allProjects = await client.getAll('projects', {
+  perPage: 50  // 50 items per page (default: 100)
+});
+```
+
+## OAuth Authentication
+
+### Authorization Flow
+
+```typescript
+// 1. Get OAuth authorization URL
+const authUrl = client.getOAuthUrl('http://localhost:3000/callback');
+// Redirect user to authUrl
+
+// 2. Exchange authorization code for tokens
+const tokens = await client.exchangeOAuthCode(code, 'http://localhost:3000/callback');
+// tokens contains: access_token, refresh_token, expires_in, etc.
+
+// 3. Use tokens for authenticated requests (USER-SPECIFIC DATA)
+const currentUser = await client.get('users/me', {
+  token: tokens
+});
+console.log(`Welcome ${currentUser.displayname}!`);
+```
+
+### Using Custom Redirect URI
+
+```typescript
+// Set redirect URI in constructor
+const client = new IntraApiProxy('client_id', 'client_secret', {
+  redirect_uri: 'http://localhost:3000/callback'
+});
+
+// Or pass it to getOAuthUrl
+const authUrl = client.getOAuthUrl('http://localhost:3000/callback');
+```
+
+## Utility Methods
+
+### URL Builder
+
+```typescript
+// Create a URL object for the API
+const userUrl = client.URL('users/jdoe');
+console.log(userUrl.toString()); // "https://api.intra.42.fr/v2/users/jdoe"
+
+// Build URLs for specific endpoints
+const campusUrl = client.URL('campus/1/users');
+const projectUrl = client.URL('projects/libft');
+const coalitionUrl = client.URL('coalitions/1/users');
+```
+
+## Error Handling
+
+The library includes automatic retry logic for rate limiting (429) and authentication (401) errors:
+
+```typescript
+try {
+  const user = await client.get('users/jdoe');
+  console.log(`Found user: ${user.displayname}`);
+} catch (error) {
+  if (error.status === 404) {
+    console.error('User not found');
+  } else if (error.status === 403) {
+    console.error('Access forbidden - check your token permissions');
+  } else {
+    console.error('Request failed after retries:', error.message);
+  }
+}
+```
+
+## Rate Limiting
+
+Requests are automatically throttled based on the configured rate limit. The default is 2 requests per second to comply with 42's API limits.
+
+## Logging
+
+By default, the library logs all requests with status codes:
+
+```
+✅ 200 GET    https://api.intra.42.fr/v2/users/jdoe
+✅ 200 GET    https://api.intra.42.fr/v2/campus/1
+🔄 429 GET    https://api.intra.42.fr/v2/projects retry 1/5
+✅ 200 GET    https://api.intra.42.fr/v2/projects retry 1/5
+```
+
+Disable logging by setting `logs: false` in the configuration.
+
+## TypeScript Support
+
+This library is written in TypeScript and includes full type definitions:
+
+```typescript
+import { FortytwoIntraClient } from '@ibertran/fortytwo-intra-client';
+
+// Types are automatically inferred
+const client = new FortytwoIntraClient('client_id', 'client_secret');
+```
+
+### OAuth Flow Example
+
+```typescript
+import express from 'express';
+import { FortytwoIntraClient } from '@ibertran/fortytwo-intra-client';
+
+const app = express();
+const client = new FortytwoIntraClient(
+  process.env.INTRA_CLIENT_ID!,
+  process.env.INTRA_CLIENT_SECRET!,
+  { 
+    redirect_uri: 'http://localhost:3000/callback',
+    oauth_scope: ['public']
+  }
+);
+
+// Redirect to 42 OAuth
+app.get('/login', (req, res) => {
+  const authUrl = client.getOAuthUrl();
+  res.redirect(authUrl);
+});
+
+// Handle OAuth callback
+app.get('/callback', async (req, res) => {
+  try {
+    const { code } = req.query;
+    const token = await client.exchangeOAuthCode(code as string);
+    
+    // Use tokens to make authenticated requests (accessing personal data)
+    const userData = await client.get('users/me', { token: token });
+        
+    res.json({ 
+      user: {
+        login: userData.login,
+        displayname: userData.displayname,
+        email: userData.email,
+        level: userData.cursus_users[0]?.level || 0,
+        wallet: userData.wallet,
+        campus: userData.campus[0]?.name
+      },
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+app.listen(3000, () => {
+  console.log('Server running on http://localhost:3000');
+  console.log('Visit http://localhost:3000/login to start OAuth flow');
+});
+```

package/dist/HttpError.d.ts

@@ -0,0 +1,9 @@
+declare class HttpError extends Error {
+    status: number | null;
+    url: string | null;
+    details: any;
+    constructor(err: any);
+}
+export declare function simplifySuperagentError(err: any): HttpError;
+export declare function isSuperAgentError(err: any): boolean;
+export {};

package/dist/HttpError.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simplifySuperagentError = simplifySuperagentError;
+exports.isSuperAgentError = isSuperAgentError;
+class HttpError extends Error {
+    status;
+    url;
+    details;
+    constructor(err) {
+        super(err.message || "Unknown API error");
+        this.name = "HttpError";
+        this.status = err.status || null;
+        this.url = err.response?.request?.url || null;
+        this.details = err.response?.body || null;
+    }
+}
+function simplifySuperagentError(err) {
+    if (!err) {
+        return new HttpError({ message: "Unknown error" });
+    }
+    return new HttpError(err);
+}
+function isSuperAgentError(err) {
+    return (err && typeof err === "object" && ("status" in err || "response" in err));
+}

package/dist/index.d.ts

@@ -0,0 +1,43 @@
+import { inputOptions, perPage } from "./types";
+export interface FortytwoIntraClientConf {
+    redirect_uri: string | null;
+    base_url: string;
+    token_url: string;
+    oauth_url: string;
+    token_info_url: string;
+    scopes: string[];
+    rate: number;
+    maxRetry: number;
+    logs: boolean;
+    errors: boolean;
+}
+export declare class FortytwoIntraClient {
+    private client_id;
+    private client_secret;
+    private redirect_uri;
+    private base_url;
+    private token_url;
+    private oauth_url;
+    private token_info_url;
+    private scopes;
+    private throttler;
+    private retryOn;
+    private maxRetry;
+    private logs;
+    private access_token;
+    constructor(client_id: string, client_secret: string, conf: Partial<FortytwoIntraClientConf>);
+    private generateToken;
+    private fetch;
+    private reqHandler;
+    private logSuccess;
+    private logError;
+    get(endpoint: URL | string, options?: Omit<inputOptions, "body">): Promise<any>;
+    post(endpoint: URL | string, options?: inputOptions): Promise<any>;
+    patch(endpoint: URL | string, options: inputOptions): Promise<any>;
+    delete(endpoint: URL | string, options: inputOptions): Promise<any>;
+    getAll(endpoint: URL | string, options?: inputOptions & perPage): Promise<any>;
+    URL(endpoint: string): URL;
+    getOAuthUrl(redirect_uri?: string | null): string;
+    exchangeOAuthCode(code: string, redirect_uri?: string): Promise<any>;
+    tokenInfos(): Promise<any>;
+}

package/dist/index.js

@@ -0,0 +1,280 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FortytwoIntraClient = void 0;
+const superagent = __importStar(require("superagent"));
+// @ts-ignore
+const superagent_throttle_1 = __importDefault(require("superagent-throttle"));
+const utils_1 = require("./utils");
+const HttpError_1 = require("./HttpError");
+const defaultConf = {
+    redirect_uri: null,
+    base_url: "https://api.intra.42.fr/v2/",
+    token_url: "https://api.intra.42.fr/oauth/token",
+    oauth_url: "https://api.intra.42.fr/oauth/authorize",
+    token_info_url: "https://api.intra.42.fr/oauth/token/info",
+    scopes: ["public"],
+    rate: 2,
+    maxRetry: 5,
+    logs: true,
+    errors: true,
+};
+class FortytwoIntraClient {
+    client_id;
+    client_secret;
+    redirect_uri;
+    base_url;
+    token_url;
+    oauth_url;
+    token_info_url;
+    scopes;
+    throttler;
+    retryOn;
+    maxRetry;
+    logs;
+    access_token;
+    constructor(client_id, client_secret, conf) {
+        this.client_id = client_id;
+        this.client_secret = client_secret;
+        const config = { ...defaultConf, ...conf };
+        this.redirect_uri = config.redirect_uri;
+        this.base_url = config.base_url;
+        this.token_url = config.token_url;
+        this.oauth_url = config.oauth_url;
+        this.token_info_url = config.token_info_url;
+        this.scopes = config.scopes;
+        this.throttler = new superagent_throttle_1.default({
+            rate: config.rate,
+            ratePer: 1100,
+            concurrent: config.rate - 1 > 0 ? config.rate - 1 : 1,
+        });
+        this.retryOn = [401, 429, 500];
+        this.maxRetry = config.maxRetry;
+        this.logs = config.logs;
+        this.access_token = null;
+    }
+    async generateToken() {
+        const res = await superagent.post(this.token_url).send({
+            grant_type: "client_credentials",
+            client_id: this.client_id,
+            client_secret: this.client_secret,
+            scope: this.scopes.join(" "),
+        });
+        return res.body.access_token;
+    }
+    async fetch(url, options) {
+        const { method, body } = options;
+        const req = (0, utils_1.initRequest)(method, url);
+        if (!options.token && !this.access_token) {
+            this.access_token = await this.generateToken();
+        }
+        // Attach access_token
+        const accessToken = options.token
+            ? options.token.access_token
+            : this.access_token;
+        req.set("Authorization", `Bearer ${accessToken}`);
+        // Add query string
+        if (options.query)
+            req.query(options.query);
+        // Send body if any is provided
+        if (body)
+            req.send(body);
+        // Throttle resquest based on rate limit
+        req.use(this.throttler.plugin());
+        return req;
+    }
+    async reqHandler(url, options) {
+        try {
+            const res = await this.fetch(url, options);
+            this.logSuccess(res, options);
+            return res;
+        }
+        catch (err) {
+            if ((0, HttpError_1.isSuperAgentError)(err)) {
+                const { attempt, maxRetry } = options;
+                this.logError(err, url, options);
+                if (maxRetry > 0 &&
+                    attempt < maxRetry &&
+                    this.retryOn.includes(err.status)) {
+                    if (err.status === 401) {
+                        this.access_token = null;
+                    }
+                    options.attempt++;
+                    return this.reqHandler(url, options);
+                }
+                else {
+                    throw (0, HttpError_1.simplifySuperagentError)(err);
+                }
+            }
+            else {
+                throw err;
+            }
+        }
+    }
+    logSuccess(res, options) {
+        const method = options.method.padEnd(6, " ");
+        const color = "\x1b[42m";
+        const reset = "\x1b[0m";
+        const msg = `${color + res.status + reset} ${method} ${res.request.url}${options.attempt ? ` retry ${options.attempt}/${options.maxRetry}` : ``}`;
+        console.log(msg);
+    }
+    logError(err, url, options) {
+        const method = options.method.padEnd(6, " ");
+        const color = "\x1b[41m";
+        const reset = "\x1b[0m";
+        const msg = `${color + err.status + reset} ${method} ${err.response.request.url}${options.attempt ? ` retry ${options.attempt}/${options.maxRetry}` : ``}`;
+        console.log(msg, JSON.stringify(err.response.body, null, 2));
+    }
+    // Public methods
+    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,
+            ...options,
+        });
+        return res.body;
+    }
+    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,
+            ...options,
+        });
+        return res.body;
+    }
+    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,
+            ...options,
+        });
+        return res.body;
+    }
+    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,
+            ...options,
+        });
+        return res.body;
+    }
+    async getAll(endpoint, options = {}) {
+        if (endpoint instanceof URL === false) {
+            endpoint = new URL(endpoint, this.base_url);
+        }
+        const perPage = options.perPage || 100;
+        let url = new URL(endpoint);
+        const initialRes = await this.reqHandler(url, {
+            method: "GET",
+            attempt: 0,
+            maxRetry: this.maxRetry,
+            ...options,
+            query: {
+                page: 1,
+                per_page: 100,
+            },
+        });
+        let lastPage;
+        try {
+            lastPage = (0, utils_1.getLastPage)(initialRes.header["link"]);
+        }
+        catch (err) {
+            return initialRes.body;
+        }
+        const promises = [];
+        for (let i = 2; i <= lastPage; i++) {
+            url = new URL(endpoint);
+            url.searchParams.append("per_page", perPage.toString());
+            url.searchParams.append("page", i.toString());
+            promises.push(this.reqHandler(url, {
+                method: "GET",
+                attempt: 0,
+                maxRetry: this.maxRetry,
+                ...options,
+            }));
+        }
+        return Promise.all(promises).then((values) => {
+            return initialRes.body.concat(...values.map((value) => value.body));
+        });
+    }
+    URL(endpoint) {
+        return new URL(endpoint, this.base_url);
+    }
+    getOAuthUrl(redirect_uri = null) {
+        redirect_uri ??= this.redirect_uri;
+        if (!redirect_uri) {
+            throw new Error(`undefined redirect_uri`);
+        }
+        const url = new URL(this.oauth_url);
+        url.searchParams.set("client_id", this.client_id);
+        url.searchParams.set("redirect_uri", redirect_uri);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("scope", this.scopes.join(" "));
+        return url.toString();
+    }
+    async exchangeOAuthCode(code, redirect_uri) {
+        const res = await superagent.post(this.token_url).send({
+            grant_type: "authorization_code",
+            client_id: this.client_id,
+            client_secret: this.client_secret,
+            redirect_uri: redirect_uri ? redirect_uri : this.redirect_uri,
+            code: code,
+        });
+        return res.body;
+    }
+    async tokenInfos() {
+        return this.get(this.token_info_url);
+    }
+}
+exports.FortytwoIntraClient = FortytwoIntraClient;

package/dist/types.d.ts

@@ -0,0 +1,20 @@
+export type Method = "GET" | "POST" | "PATCH" | "DELETE";
+export type userToken = {
+    access_token: string;
+};
+export type reqOptions = {
+    method: Method;
+    maxRetry: number;
+    attempt: number;
+    body?: any;
+    token?: userToken;
+    query?: querystring;
+};
+export type querystring = Record<string, string | number | boolean | Array<string | number | boolean>>;
+export type perPage = {
+    perPage?: number;
+};
+type internal = "method" | "attempt";
+type optional = "maxRetry";
+export type inputOptions = Omit<reqOptions, internal | optional> & Partial<Pick<reqOptions, optional>>;
+export {};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import * as superagent from "superagent";
+import { Method } from "./types";
+export declare function initRequest(method: Method, url: URL): superagent.Request;
+export declare function getLastPage(header: string | undefined): number;

package/dist/utils.js

@@ -0,0 +1,79 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initRequest = initRequest;
+exports.getLastPage = getLastPage;
+const superagent = __importStar(require("superagent"));
+function initRequest(method, url) {
+    const endpoint = url.toString();
+    switch (method) {
+        case "GET":
+            return superagent.get(endpoint);
+        case "POST":
+            return superagent.post(endpoint);
+        case "PATCH":
+            return superagent.patch(endpoint);
+        case "DELETE":
+            return superagent.delete(endpoint);
+        default:
+            throw Error("Invalid HTTP method");
+    }
+}
+function getLastPage(header) {
+    if (!header) {
+        throw Error("No pagination link header");
+    }
+    const paginationlinks = header
+        .split(",")
+        .reduce((links, part) => {
+        const match = part.match(/<([^>]+)>\s*;\s*rel="([^"]+)"/);
+        if (match) {
+            const url = match[1];
+            const rel = match[2];
+            links[rel] = url;
+        }
+        return links;
+    }, {});
+    if (!paginationlinks.last) {
+        throw Error("Missing last page link");
+    }
+    const lastPageUrl = new URL(paginationlinks.last);
+    const rawLastPage = lastPageUrl.searchParams.get("page");
+    const lastPage = rawLastPage ? parseInt(rawLastPage, 10) : undefined;
+    if (!lastPage || isNaN(lastPage)) {
+        throw Error("Invalid last page link");
+    }
+    return lastPage;
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@ibertran/fortytwo-intra-client",
+  "version": "2.0.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "dependencies": {
+    "superagent": "^10.2.1",
+    "superagent-throttle": "^1.0.1"
+  },
+  "devDependencies": {
+    "@types/superagent": "^8.1.9",
+    "ts-node": "^10.9.2",
+    "tsc": "^2.0.4"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}