@ezpaarse-project/ezreeport-sdk-js 1.0.0-beta.1

package/dist/node/package.json

@@ -0,0 +1,56 @@
+{
+    "name": "ezreeport-sdk-js",
+    "version": "1.0.0-beta.3",
+    "description": "JS SDK to communicate with ezReeport API",
+    "homepage": "https://github.com/ezpaarse-project/ezreeport#readme",
+    "bugs": {
+        "url": "https://github.com/ezpaarse-project/ezreeport/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+ssh://git@github.com/ezpaarse-project/ezreeport.git"
+    },
+    "license": "CeCILL",
+    "author": "oxypomme",
+    "exports": {
+        "browser": {
+            "import": "./dist/browser/ezreeport-sdk-js.mjs",
+            "require": "./dist/browser/ezreeport-sdk-js.umd.js"
+        },
+        "node": {
+            "default": "./dist/node/index.js"
+        }
+    },
+    "types": "./dist/types/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "run-s build:web build:node build:types",
+        "build:node-vite": "tsc && BUILD_TARGET=node vite build",
+        "build:node": "tsc --project tsconfig.node.json",
+        "build:types": "tsc && BUILD_TARGET=types vite build",
+        "build:web": "tsc && BUILD_TARGET=browser vite build",
+        "lint": "eslint --fix .",
+        "test": "npm run build && npm -w ezreeport-tests run test:sdk"
+    },
+    "lint-staged": {
+        "*.ts": [
+            "eslint --fix"
+        ]
+    },
+    "dependencies": {
+        "axios": "^1.3.5",
+        "date-fns": "^2.29.3",
+        "events": "^3.3.0",
+        "typescript": "^5.0.4",
+        "vite": "^4.2.1",
+        "vite-plugin-dts": "^2.2.0"
+    },
+    "devDependencies": {
+        "@types/node": "^18.15.11"
+    },
+    "engines": {
+        "node": "^16 || ^18"
+    }
+}

package/dist/types/index.d.ts

@@ -0,0 +1,24 @@
+export * as auth from './modules/auth.public';
+export * as crons from './modules/crons.public';
+export * as health from './modules/health.public';
+export * as history from './modules/history.public';
+export * as namespaces from './modules/namespaces.public';
+export * as queues from './modules/queues.public';
+export * as reports from './modules/reports.public';
+export * as setup from './modules/setup.public';
+export * as tasks from './modules/tasks.public';
+export * as templates from './modules/templates.public';
+export { version } from '../package.json';
+export type EzReeportSDK = {
+    auth: typeof import('./modules/auth.public');
+    crons: typeof import('./modules/crons.public');
+    health: typeof import('./modules/health.public');
+    history: typeof import('./modules/history.public');
+    namespaces: typeof import('./modules/namespaces.public');
+    queues: typeof import('./modules/queues.public');
+    reports: typeof import('./modules/reports.public');
+    setup: typeof import('./modules/setup.public');
+    tasks: typeof import('./modules/tasks.public');
+    templates: typeof import('./modules/templates.public');
+    version: string;
+};

package/dist/types/lib/axios.d.ts

@@ -0,0 +1,51 @@
+import { Axios, AxiosResponse } from 'axios';
+export interface ApiResponse<T> {
+    /**
+     * HTTP Status
+     */
+    status: {
+        code: number;
+        message: string;
+    };
+    /**
+     * Content of the response
+     */
+    content: T;
+}
+export interface PaginatedApiResponse<T> extends ApiResponse<T> {
+    meta: {
+        /**
+         * Count of items in response
+         */
+        count: number;
+        /**
+         * Count of items wanted
+         */
+        size: number;
+        /**
+         * Count of items available
+         */
+        total: number;
+        /**
+         * Id of last item in response
+         */
+        lastId?: unknown;
+    };
+}
+/**
+ * Start axios request with basic error handling
+ *
+ * @param method The request's method
+ * @param params The other params of axios
+ *
+ * @returns Response
+ */
+export declare const axiosWithErrorFormatter: <T, Method extends "get" | "post" | "put" | "patch" | "delete">(method: Method, ...params: Parameters<Axios[Method]>) => Promise<AxiosResponse<T, any>>;
+declare const _default: import("axios").AxiosInstance & {
+    $get: <T>(url: string, config?: import("axios").AxiosRequestConfig<unknown> | undefined) => Promise<ApiResponse<T>>;
+    $post: <T_1>(url: string, data?: unknown, config?: import("axios").AxiosRequestConfig<unknown> | undefined) => Promise<ApiResponse<T_1>>;
+    $put: <T_2>(url: string, data?: unknown, config?: import("axios").AxiosRequestConfig<unknown> | undefined) => Promise<ApiResponse<T_2>>;
+    $patch: <T_3>(url: string, data?: unknown, config?: import("axios").AxiosRequestConfig<unknown> | undefined) => Promise<ApiResponse<T_3>>;
+    $delete: <T_4>(url: string, config?: import("axios").AxiosRequestConfig<unknown> | undefined) => Promise<ApiResponse<T_4>>;
+};
+export default _default;

package/dist/types/lib/promises.d.ts

@@ -0,0 +1,18 @@
+import EventEmitter from 'events';
+interface EventEmitterBase {
+    on: (...p: Parameters<EventEmitter['on']>) => this;
+    once: (...p: Parameters<EventEmitter['once']>) => this;
+    off: (...p: Parameters<EventEmitter['off']>) => this;
+    emit: (...p: Parameters<EventEmitter['emit']>) => this;
+}
+export type EventfulPromise<T> = Promise<T> & EventEmitterBase;
+/**
+ * Attach a `EventEmitter` to a `Promise` returned by the `executor`
+ *
+ * @param executor Executor returning the promise. The `emitter` is passed to the executor as param.
+ * @param emitter `EventEmitter` attached. By default it's a new instance.
+ *
+ * @returns The EventfulPromise
+ */
+declare const createEventfulPromise: <T>(executor: (emitter: EventEmitter | EventEmitterBase) => Promise<T>, emitter?: EventEmitter) => EventfulPromise<T>;
+export default createEventfulPromise;

package/dist/types/lib/utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Async version of `setTimeout`
+ *
+ * @param ms Time to wait
+ */
+export declare const setTimeoutAsync: (ms: number) => Promise<unknown>;
+export interface RawPeriod {
+    start: string;
+    end: string;
+}
+export interface Period extends Omit<RawPeriod, 'start' | 'end'> {
+    start: Date;
+    end: Date;
+}
+/**
+ * Transform raw data from JSON, to JS usable data
+ *
+ * @param period Raw period
+ *
+ * @returns Parsed period
+ */
+export declare const parsePeriod: (period: RawPeriod) => Period;

package/dist/types/modules/auth.d.ts

@@ -0,0 +1,90 @@
+import { ApiResponse } from '../lib/axios';
+import { type Namespace, type RawNamespace } from './namespaces';
+export declare enum Access {
+    READ = "READ",
+    READ_WRITE = "READ_WRITE",
+    SUPER_USER = "SUPER_USER"
+}
+interface RawMembership {
+    access: Access;
+    namespace: RawNamespace;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface Membership extends Omit<RawMembership, 'namespace' | 'createdAt' | 'updatedAt'> {
+    namespace: Namespace;
+    createdAt: Date;
+    updatedAt?: Date;
+}
+interface RawUser {
+    username: string;
+    token: string;
+    isAdmin: true;
+    memberships: RawMembership[];
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface User extends Omit<RawUser, 'memberships' | 'createdAt' | 'updatedAt'> {
+    memberships: Membership[];
+    createdAt: Date;
+    updatedAt?: Date;
+}
+export type Permissions = {
+    /**
+     * General routes independent of namespaces
+     */
+    general: {
+        [routeId: string]: boolean;
+    };
+    /**
+     * Routes who are dependent of namespaces
+     *
+     * If wanted namespace isn't present, then user doesn't have access
+     */
+    namespaces: {
+        [namespaceId: string]: {
+            [routeId: string]: boolean;
+        };
+    };
+};
+/**
+ * Set auth token to axios
+ *
+ * @param token The auth token
+ */
+export declare const login: (token: string) => void;
+/**
+ * Unset auth token from axios
+ */
+export declare const logout: () => void;
+/**
+ * Check if auth token is setup in axios. **DOESN'T CHECK IF TOKEN IS VALID !**
+ *
+ * @returns If auth token is setup
+ */
+export declare const isLogged: () => boolean;
+/**
+ * Get logged user info
+ *
+ * Needs `general.auth-get` permission
+ *
+ * @returns The logged user info
+ */
+export declare const getCurrentUser: () => Promise<ApiResponse<User>>;
+/**
+ * Get logged user permissions
+ *
+ * Needs `namespaces[namespaceId].auth-get-permissions` permission
+ *
+ * @returns Permissions
+ */
+export declare const getCurrentPermissions: () => Promise<ApiResponse<Permissions>>;
+/**
+ * Get logged user accessible namespaces
+ *
+ * Needs `namespaces[namespaceId].auth-get-namespaces` permission
+ *
+ * @returns Permissions
+ */
+export declare const getCurrentNamespaces: () => Promise<ApiResponse<Namespace[]>>;
+export {};

package/dist/types/modules/auth.public.d.ts

@@ -0,0 +1 @@
+export { type Access, type Membership, type User, type Permissions, login, logout, isLogged, getCurrentUser, getCurrentNamespaces, getCurrentPermissions, } from './auth';

package/dist/types/modules/crons.d.ts

@@ -0,0 +1,78 @@
+import { type ApiResponse } from '../lib/axios';
+interface RawCron {
+    name: string;
+    running: boolean;
+    nextRun?: string;
+    lastRun?: string;
+}
+export interface Cron extends Omit<RawCron, 'nextRun' | 'lastRun'> {
+    nextRun?: Date;
+    lastRun?: Date;
+}
+/**
+ * Get all available crons
+ *
+ * Needs `general.crons-get` permission
+ *
+ * @returns All crons' info
+ */
+export declare const getAllCrons: () => Promise<ApiResponse<Cron[]>>;
+/**
+ * Get cron info
+ *
+ * Needs `general.crons-get-cron` permission
+ *
+ * @param name Cron name
+ *
+ * @returns Cron's info
+ */
+export declare const getCron: (name: Cron['name']) => Promise<ApiResponse<Cron>>;
+/**
+ * Start cron
+ *
+ * Needs `general.crons-put-cron-start` permission
+ *
+ * @param name Cron name
+ *
+ * @returns Cron's info
+ */
+export declare const startCron: (name: Cron['name']) => Promise<{
+    content: Cron;
+    status: {
+        code: number;
+        message: string;
+    };
+}>;
+/**
+ * Stop cron
+ *
+ * Needs `general.crons-put-cron-stop` permission
+ *
+ * @param name Cron name
+ *
+ * @returns Cron's info
+ */
+export declare const stopCron: (name: Cron['name']) => Promise<{
+    content: Cron;
+    status: {
+        code: number;
+        message: string;
+    };
+}>;
+/**
+ * Force cron to run
+ *
+ * Needs `general.crons-post-cron-force` permission
+ *
+ * @param name Cron name
+ *
+ * @returns Cron's info
+ */
+export declare const forceCron: (name: Cron['name']) => Promise<{
+    content: Cron;
+    status: {
+        code: number;
+        message: string;
+    };
+}>;
+export {};

package/dist/types/modules/crons.public.d.ts

@@ -0,0 +1 @@
+export { type Cron, getAllCrons, getCron, startCron, stopCron, forceCron, } from './crons';

package/dist/types/modules/health.d.ts

@@ -0,0 +1,53 @@
+interface PingResultSuccess {
+    name: string;
+    status: true;
+    elapsedTime: number;
+    statusCode: number;
+}
+interface PingResultFail {
+    name: string;
+    status: false;
+    error: string;
+}
+export type PingResult = PingResultSuccess | PingResultFail;
+/**
+ * Get all services connected to current
+ *
+ * Needs `general.health-get` permission
+ *
+ * @returns The current service & the name of connected ones
+ */
+export declare const getAllConnectedServices: () => Promise<import("../lib/axios").ApiResponse<{
+    current: string;
+    currentVersion: string;
+    services: PingResult['name'][];
+}>>;
+/**
+ * Check connection for all connected service from current
+ *
+ * Needs `general.health-get-all` permission
+ *
+ * @returns The connection status for all services
+ */
+export declare const checkAllConnectedService: () => Promise<import("../lib/axios").ApiResponse<PingResult[]>>;
+/**
+ * Check connection of a specific service from current
+ *
+ * Needs `general.health-get-service` permission
+ *
+ * @param service The name of the service
+ *
+ * @returns The connection status of the service from current
+ */
+export declare const checkConnectedService: (service: PingResult['name']) => Promise<import("../lib/axios").ApiResponse<PingResult>>;
+/**
+ * Check connection of current service
+ *
+ * It's useful when the app will have limited connection, or if you just want the processing time.
+ *
+ * Needs `general.health-get-all` & `general.health-get-service` permission
+ *
+ * @returns The connection status of current service
+ */
+export declare const checkCurrentService: () => Promise<import("../lib/axios").ApiResponse<PingResult>>;
+export {};

package/dist/types/modules/health.public.d.ts

@@ -0,0 +1 @@
+export { type PingResult, getAllConnectedServices, checkAllConnectedService, checkConnectedService, checkCurrentService, } from './health';

package/dist/types/modules/history.d.ts

@@ -0,0 +1,38 @@
+import { type PaginatedApiResponse } from '../lib/axios';
+import { type TaskWithNamespace } from './tasks.base';
+export interface RawHistory {
+    id: string;
+    taskId: string;
+    type: string;
+    message: string;
+    data?: object;
+    createdAt: string;
+}
+export interface History extends Omit<RawHistory, 'createdAt'> {
+    createdAt: Date;
+}
+export interface HistoryWithTask extends Omit<History, 'taskId'> {
+    task: TaskWithNamespace;
+}
+/**
+ * Transform raw data from JSON, to JS usable data
+ *
+ * @param entry Raw history entry
+ *
+ * @returns Parsed history entry
+ */
+export declare const parseHistory: (entry: RawHistory) => History;
+/**
+ * Get all available history entries
+ *
+ * Needs `namespaces[namespaceId].history-get` permission
+ *
+ * @param paginationOpts Options for pagination
+ * @param namespaces
+ *
+ * @returns All history entries' info
+ */
+export declare const getAllEntries: (paginationOpts?: {
+    previous?: History['id'];
+    count?: number;
+}, namespaces?: string[]) => Promise<PaginatedApiResponse<HistoryWithTask[]>>;

package/dist/types/modules/history.public.d.ts

@@ -0,0 +1 @@
+export { type History, type HistoryWithTask, getAllEntries, } from './history';

package/dist/types/modules/institutions.d.ts

@@ -0,0 +1,56 @@
+import { type ApiResponse } from '../lib/axios';
+interface RawInstitution {
+    id: string;
+    name: string;
+    website?: string;
+    uai?: string;
+    auto: {
+        ezmesure: boolean;
+        ezpaarse: boolean;
+        report: boolean;
+        sushi?: boolean;
+    };
+    validated?: boolean;
+    indexCount?: number;
+    domains?: string[];
+    logoId?: string;
+    updatedAt?: string;
+    createdAt: string;
+    acronym?: string;
+    city?: string;
+    type?: string;
+    linkedinUrl?: string;
+    facebookUrl?: string;
+    twitterUrl?: string;
+    creator?: string;
+    youtubeUrl?: string;
+    indexPrefix?: string;
+    role?: string;
+    space?: string;
+    docContactName?: string;
+    techContactName?: string;
+    hidePartner?: boolean;
+    sushiReadySince?: string;
+}
+export interface Institution extends Omit<RawInstitution, 'updatedAt' | 'createdAt' | 'sushiReadySince'> {
+    updatedAt?: Date;
+    createdAt: Date;
+    sushiReadySince?: Date;
+}
+/**
+ * Get all available institutions for authed user
+ *
+ * Needs `institutions-get` permission
+ *
+ * @returns Available institutions
+ */
+export declare const getInstitutions: () => Promise<ApiResponse<Institution[]>>;
+/**
+ * Get specific institution that is available for authed user
+ *
+ * Needs `institutions-get-id` permission
+ *
+ * @returns Available institution
+ */
+export declare const getInstitution: (id: Institution['id']) => Promise<ApiResponse<Institution>>;
+export {};

package/dist/types/modules/namespaces.d.ts

@@ -0,0 +1,19 @@
+export interface RawNamespace {
+    id: string;
+    name: string;
+    logoId?: string;
+    createdAt: string;
+    updatedAt?: string;
+}
+export interface Namespace extends Omit<RawNamespace, 'createdAt' | 'updatedAt'> {
+    createdAt: Date;
+    updatedAt?: Date;
+}
+/**
+ * Transform raw data from JSON, to JS usable data
+ *
+ * @param namespace Raw namespace
+ *
+ * @returns Parsed namespace
+ */
+export declare const parseNamespace: (namespace: RawNamespace) => Namespace;

package/dist/types/modules/namespaces.public.d.ts

@@ -0,0 +1 @@
+export { type Namespace, } from './namespaces';

package/dist/types/modules/queues.d.ts

@@ -0,0 +1,93 @@
+import { type PaginatedApiResponse, type ApiResponse } from '../lib/axios';
+export interface Job<Data> {
+    id: number | string;
+    queue: string;
+    data: Data;
+}
+type JobStatus = 'completed' | 'waiting' | 'active' | 'delayed' | 'failed' | 'paused' | 'stuck';
+interface RawFullJob<Data, Result> {
+    id: Job<Data>['id'];
+    data: Job<Data>['data'];
+    result?: Result;
+    progress: number;
+    added: string;
+    started?: string;
+    ended?: string;
+    attempts: number;
+    status: JobStatus;
+}
+export interface FullJob<Data, Result> extends Omit<RawFullJob<Data, Result>, 'added' | 'started' | 'ended'> {
+    added: Date;
+    started?: Date;
+    ended?: Date;
+}
+export interface Queue {
+    status: 'paused' | 'active';
+    name: string;
+}
+/**
+ * Get all available queues
+ *
+ * Needs `general.queues-get` permission
+ *
+ * @returns All queues' names
+ */
+export declare const getAllQueues: () => Promise<ApiResponse<Queue[]>>;
+/**
+ * Pause queue
+ *
+ * Needs `general.queues-put-queue-pause` permission
+ *
+ * @param queueName Name of the queue
+ *
+ * @returns queue info
+ */
+export declare const pauseQueue: (queueName: string) => Promise<ApiResponse<Queue>>;
+/**
+ * Resume queue
+ *
+ * Needs `general.queues-put-queue-resume` permission
+ *
+ * @param queueName Name of the queue
+ *
+ * @returns queue info
+ */
+export declare const resumeQueue: (queueName: string) => Promise<ApiResponse<Queue>>;
+/**
+ * Get queue info
+ *
+ * Needs `general.queues-get-queue-jobs` permission
+ *
+ * @param queueName Name of the queue
+ *
+ * @returns queue info
+ */
+export declare const getQueueJobs: <Data, Result>(queueName: string, paginationOpts?: {
+    previous?: string | number | undefined;
+    count?: number | undefined;
+} | undefined) => Promise<PaginatedApiResponse<FullJob<Data, Result>[]>>;
+/**
+ * Get job info
+ *
+ * Needs `namespaces[namespaceId].queues-get-queue-jobs-jobId` permission
+ *
+ * @param queueName Name of queue where job is
+ * @param jobId Id of the job in queue
+ * @param namespaces
+ *
+ * @returns Job full info
+ */
+export declare const getJob: <Data, Result>(queueName: string, jobId: string | number, namespaces?: string[]) => Promise<ApiResponse<FullJob<Data, Result>>>;
+/**
+ * Retry job that failed
+ *
+ * Needs `namespaces[namespaceId].queues-post-queue-jobs-jobId-retry` permission
+ *
+ * @param queueName Name of queue where job is
+ * @param jobId Id of the job in queue
+ * @param namespaces
+ *
+ * @returns queue info
+ */
+export declare const retryJob: <Data, Result>(queueName: string, jobId: string | number, namespaces?: string[]) => Promise<ApiResponse<FullJob<Data, Result>>>;
+export {};

package/dist/types/modules/queues.public.d.ts

@@ -0,0 +1 @@
+export { type Job, type FullJob, type Queue, getAllQueues, pauseQueue, resumeQueue, getQueueJobs, getJob, retryJob, } from './queues';