@grandlinex/swagger-mate 1.3.4 → 1.3.5

package/dist/cjs/Swagger/debug/BaseCon.js

@@ -1,432 +0,0 @@
-"use strict";
-/**
- * THIS FILE IS AUTOMATICALLY GENERATED
- * DO NOT EDIT THIS FILE
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isErrorType = isErrorType;
-const form_data_1 = __importDefault(require("form-data"));
-function isErrorType(x) {
-    return x && typeof x === 'object' && x.type === 'error';
-}
-/**
- * BaseCon provides a minimal client for interacting with an HTTP backend.
- * It manages connection state, authentication tokens, and reconnection
- * logic while delegating actual HTTP requests to a supplied {@link ConHandle}.
- *
- * @class
- */
-class BaseCon {
-    /**
-     * Initializes a new instance of the client.
-     *
-     * @param {Object} conf Configuration object.
-     * @param {ConHandle} conf.con - Connection handle.
-     * @param {string} conf.endpoint - API endpoint URL.
-     * @param {(arg: any) => void} [conf.logger] - Optional logger function; defaults to console.log.
-     * @param {Record<string, string>} [conf.permanentHeader] - Optional permanent headers to include in requests.
-     * @return {void}
-     */
-    constructor(conf) {
-        this.api = conf.endpoint;
-        this.logger = conf.logger ?? console.log;
-        this.disconnected = true;
-        this.noAuth = false;
-        this.authorization = null;
-        this.con = conf.con;
-        this.permanentHeader = conf.permanentHeader || {};
-        this.reconnect = async () => {
-            this.disconnected = true;
-            return false;
-        };
-        this.onReconnect = () => Promise.resolve(true);
-        this.handle = this.handle.bind(this);
-    }
-    /**
-     * Retrieves the API endpoint.
-     *
-     * @return {string} The API endpoint string.
-     */
-    getApiEndpoint() {
-        return this.api;
-    }
-    /**
-     * Sets the API endpoint URL used by the client.
-     *
-     * @param {string} endpoint - The full URL of the API endpoint.
-     * @returns {void}
-     */
-    setApiEndpoint(endpoint) {
-        this.api = endpoint;
-    }
-    /**
-     * Indicates whether the instance is considered connected.
-     *
-     * The instance is regarded as connected when it either does not require authentication
-     * (`noAuth` is true) or it has an authorization token set (`authorization` is not null),
-     * and it is not currently marked as disconnected.
-     *
-     * @return {boolean} `true` if the instance is connected, `false` otherwise.
-     */
-    isConnected() {
-        return (this.noAuth || this.authorization !== null) && !this.disconnected;
-    }
-    /**
-     * Retrieves the current authorization token.
-     *
-     * @return {string|null} The token string used for authorization, or {@code null} if no token is set.
-     */
-    token() {
-        return this.authorization;
-    }
-    /**
-     * Returns the bearer token string if an authorization value has been set.
-     *
-     * @return {string|null} The bearer token prefixed with "Bearer ", or {@code null} when no authorization is present.
-     */
-    getBearer() {
-        if (this.authorization) {
-            return `Bearer ${this.authorization}`;
-        }
-        return null;
-    }
-    p(path, config) {
-        let pp = path;
-        if (config?.param) {
-            const e = Object.keys(config.param);
-            for (const d of e) {
-                pp = pp.replace(`{${d}}`, `${config.param[d]}`);
-            }
-        }
-        if (config?.query) {
-            const e = Object.keys(config.query);
-            const slices = [];
-            for (const d of e) {
-                if (config.query[d]) {
-                    slices.push(`${d}=${config.query[d]}`);
-                }
-            }
-            if (slices.length > 0) {
-                pp += `?${slices.join('&')}`;
-            }
-        }
-        return `${this.api}${pp}`;
-    }
-    /**
-     * Sends a ping request to the API to verify connectivity and version availability.
-     *
-     * @return {boolean} `true` if the API responded with a 200 status code and a valid version object; `false` otherwise.
-     */
-    async ping() {
-        try {
-            const version = await this.con.get(this.p('/version'));
-            return version.data?.api !== undefined && version.code === 200;
-        }
-        catch (e) {
-            this.logger('ping failed');
-            return false;
-        }
-    }
-    /**
-     * Builds the Authorization header for HTTP requests.
-     *
-     * If the instance has an authorization token, this method returns an object
-     * containing a single `Authorization` header with the Bearer token value.
-     * When no token is available, an empty header object is returned.
-     *
-     * @return {Record<string, string>} The headers object containing the
-     * `Authorization` header when applicable, otherwise an empty object.
-     */
-    tokenHeader() {
-        if (this.authorization) {
-            return {
-                Authorization: this.getBearer(),
-            };
-        }
-        return {};
-    }
-    setPermanentHeader(header) {
-        this.permanentHeader = header;
-    }
-    /**
-     * Validates the current authentication token by performing a ping and a test request
-     * to the backend. The method first ensures connectivity via {@link ping}. If the ping
-     * succeeds, it attempts to retrieve a token from the `/test/auth` endpoint using the
-     * current token in the `Authorization` header. The operation is considered successful
-     * if the response status code is 200 or 201.
-     *
-     * If any step fails, an error is logged and the method returns {@code false}. On
-     * success, it returns {@code true}.
-     *
-     * @return {Promise<boolean>} A promise that resolves to {@code true} if the token
-     * test succeeds, otherwise {@code false}.
-     */
-    async testToken() {
-        const ping = await this.ping();
-        if (ping) {
-            try {
-                const con = await this.con.get(this.p('/test/auth'), {
-                    headers: this.tokenHeader(),
-                });
-                return con.code === 200 || con.code === 201;
-            }
-            catch (e) {
-                this.logger(e);
-                this.logger('cant connect to backend');
-            }
-        }
-        this.logger('test ping failed');
-        return false;
-    }
-    /**
-     * Attempts to establish a connection to the backend without authentication.
-     *
-     * This method sends a ping request.  If the ping succeeds, it clears any
-     * existing authorization data, marks the instance as connected,
-     * enables the no‑authentication mode, and returns `true`.  If the ping
-     * fails, it logs a warning, clears authorization, marks the instance
-     * as disconnected, and returns `false`.
-     *
-     * @return {Promise<boolean>} `true` when a connection is successfully
-     * established without authentication, otherwise `false`.
-     */
-    async connectNoAuth() {
-        const ping = await this.ping();
-        if (ping) {
-            this.authorization = null;
-            this.disconnected = false;
-            this.noAuth = true;
-            return true;
-        }
-        this.logger('cant connect to backend');
-        this.authorization = null;
-        this.disconnected = true;
-        this.noAuth = false;
-        return false;
-    }
-    /**
-     * Forces a connection using the provided bearer token.
-     *
-     * @param {string|null} token The token to be used for authentication.
-     * @returns {void}
-     */
-    forceConnect(token) {
-        if (token) {
-            this.authorization = token.replace('Bearer ', '').replace('bearer ', '');
-        }
-        else {
-            this.authorization = null;
-        }
-        this.disconnected = false;
-        this.noAuth = token === null;
-    }
-    coppyFrom(con) {
-        this.authorization = con.authorization;
-        this.disconnected = con.disconnected;
-        this.noAuth = con.noAuth;
-    }
-    /**
-     * Establishes a connection to the backend using the supplied credentials.
-     * Performs a health‑check ping first; if successful, it requests an authentication
-     * token from the `/token` endpoint.  When the token is obtained, the method
-     * updates internal state (authorization header, connection flags) and, unless
-     * a dry run is requested, sets up a reconnection routine.  Any errors are
-     * logged and the method resolves to `false`.
-     *
-     * @param {string} email - The user's email address for authentication.
-     * @param {string} pw - The password (or token) for the specified user.
-     * @param {boolean} [dry=false] - If `true`, the method performs a dry run
-     *   without persisting credentials or configuring reconnection logic.
-     *
-     * @returns  Promise<boolean>  `true` if the connection was successfully
-     *   established, otherwise `false`.
-     */
-    async connect(email, pw, dry = false) {
-        const ping = await this.ping();
-        if (ping) {
-            try {
-                const token = await this.con.post(this.p('/token'), {
-                    username: email,
-                    token: pw,
-                });
-                if (token.code === 200 || token.code === 201) {
-                    if (!dry) {
-                        this.authorization = token.data.token;
-                        this.disconnected = false;
-                        this.noAuth = false;
-                        this.reconnect = async () => {
-                            return ((await this.connect(email, pw)) && (await this.testToken()));
-                        };
-                    }
-                    return true;
-                }
-            }
-            catch (e) {
-                this.logger(e);
-            }
-        }
-        this.logger('cant connect to backend');
-        this.authorization = null;
-        this.disconnected = true;
-        this.noAuth = false;
-        return false;
-    }
-    /**
-     * Performs an HTTP request using the client’s internal connection.
-     *
-     * The method verifies that the client is connected before attempting a request.
-     * It automatically injects the authorization token, permanent headers, and any
-     * headers supplied in `config`. If the request body is a `FormData` instance
-     * (or provides a `getHeaders` method), the appropriate form headers are added.
-     *
-     * Response handling:
-     * - `200` or `201`: returns `success: true` with the received data.
-     * - `498`: attempts to reconnect and retries the request once.
-     * - `401`: logs an authentication error, marks the client as disconnected.
-     * - `403` and other status codes: return `success: false` with the status code.
-     *
-     * @param {'POST'|'GET'|'PATCH'|'DELETE'} type The HTTP method to use.
-     * @param {string} path The endpoint path relative to the base URL.
-     * @param {J} [body] Optional request payload. May be `FormData` or a plain object.
-     * @param {ConHandleConfig} [config] Optional Axios-like configuration for the request.
-     * @returns {Promise<HandleRes<T>>} A promise that resolves to a `HandleRes` object
-     * containing the response data, status code, any error information, and headers.
-     */
-    async handle(type, path, body, config) {
-        if (!this.isConnected()) {
-            this.logger('Disconnected');
-            return {
-                success: false,
-                data: null,
-                code: -1,
-            };
-        }
-        let formHeader = null;
-        const cK = body;
-        if (cK &&
-            (cK instanceof form_data_1.default || typeof cK?.getHeaders === 'function')) {
-            formHeader = cK?.getHeaders?.() || {};
-        }
-        else {
-            formHeader = {};
-        }
-        let dat;
-        switch (type) {
-            case 'GET':
-                dat = await this.con.get(this.p(path, config), {
-                    ...config,
-                    headers: {
-                        ...this.tokenHeader(),
-                        ...formHeader,
-                        ...config?.headers,
-                        ...this.permanentHeader,
-                    },
-                });
-                break;
-            case 'POST':
-                dat = await this.con.post(this.p(path, config), body, {
-                    ...config,
-                    headers: {
-                        ...this.tokenHeader(),
-                        ...formHeader,
-                        ...config?.headers,
-                        ...this.permanentHeader,
-                    },
-                });
-                break;
-            case 'PATCH':
-                dat = await this.con.patch(this.p(path, config), body, {
-                    ...config,
-                    headers: {
-                        ...this.tokenHeader(),
-                        ...formHeader,
-                        ...config?.headers,
-                        ...this.permanentHeader,
-                    },
-                });
-                break;
-            case 'DELETE':
-                dat = await this.con.delete(this.p(path, config), {
-                    ...config,
-                    headers: {
-                        ...this.tokenHeader(),
-                        ...formHeader,
-                        ...config?.headers,
-                        ...this.permanentHeader,
-                    },
-                });
-                break;
-            default:
-                return {
-                    success: false,
-                    data: null,
-                    code: -1,
-                };
-        }
-        let error;
-        if (isErrorType(dat.data)) {
-            error = dat.data;
-        }
-        let x = false;
-        switch (dat.code) {
-            case 200:
-            case 201:
-                return {
-                    success: true,
-                    data: dat.data,
-                    code: dat.code,
-                    error,
-                    headers: dat.headers,
-                };
-            case 498:
-                x = await this.reconnect();
-                if (x) {
-                    this.onReconnect(this).catch((dx) => {
-                        this.logger(dx);
-                    });
-                    return this.handle(type, path, body, config);
-                }
-                this.reconnect = async () => {
-                    this.disconnected = true;
-                    return false;
-                };
-                this.disconnected = true;
-                return {
-                    success: false,
-                    data: null,
-                    code: dat.code,
-                    error,
-                    headers: dat.headers,
-                };
-            case 401:
-                this.logger('AUTH NOT VALID');
-                return {
-                    success: false,
-                    data: null,
-                    code: dat.code,
-                    error,
-                    headers: dat.headers,
-                };
-            case 403:
-                return {
-                    success: false,
-                    data: null,
-                    error,
-                    code: dat.code,
-                    headers: dat.headers,
-                };
-            default:
-                return {
-                    success: false,
-                    data: null,
-                    error,
-                    code: dat.code,
-                    headers: dat.headers,
-                };
-        }
-    }
-}
-exports.default = BaseCon;

package/dist/cjs/Swagger/debug/FetchCon.d.ts

@@ -1,3 +0,0 @@
-import { ConHandle } from './BaseCon.js';
-declare const FetchCon: ConHandle;
-export default FetchCon;

package/dist/cjs/Swagger/debug/FetchCon.js

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function fcTransform(r) {
-    const res = await r;
-    const head = {};
-    res.headers.forEach((val, key) => {
-        head[key] = val;
-    });
-    let data = null;
-    if (head['content-type']?.includes('application/json')) {
-        data = await res.json();
-    }
-    else if (head['content-type']?.includes('form-data')) {
-        data = await res.formData();
-    }
-    else if (head['content-type']?.includes('octet-stream')) {
-        data = await res.arrayBuffer();
-    }
-    else if (head['content-type']?.includes('text/plain')) {
-        data = await res.text();
-    }
-    return {
-        code: res.status,
-        data,
-        headers: head,
-    };
-}
-function bodyTransform(r, headers) {
-    if (!r) {
-        return {
-            headers,
-        };
-    }
-    if (r instanceof FormData) {
-        return {
-            body: r,
-            headers: {
-                ...headers,
-            },
-        };
-    }
-    return {
-        body: JSON.stringify(r),
-        headers: {
-            ...headers,
-            'content-type': 'application/json',
-        },
-    };
-}
-const FetchCon = {
-    get: async (url, config) => {
-        return fcTransform(fetch(url, {
-            method: 'GET',
-            headers: {
-                accept: 'application/json, text/plain, */*',
-                ...config?.headers,
-            },
-        }));
-    },
-    post: async (url, body, config) => {
-        return fcTransform(fetch(url, {
-            method: 'POST',
-            ...bodyTransform(body, config?.headers),
-        }));
-    },
-    patch: async (url, body, config) => {
-        return fcTransform(fetch(url, {
-            method: 'PATCH',
-            ...bodyTransform(body, config?.headers),
-        }));
-    },
-    delete: async (url, config) => {
-        return fcTransform(fetch(url, {
-            method: 'DELETE',
-            headers: config?.headers,
-        }));
-    },
-};
-exports.default = FetchCon;

package/dist/cjs/Swagger/debug/NodeCon.d.ts

@@ -1,3 +0,0 @@
-import { ConHandle } from './BaseCon.js';
-declare const NodeCon: ConHandle;
-export default NodeCon;

package/dist/cjs/Swagger/debug/NodeCon.js

@@ -1,158 +0,0 @@
-"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 });
-const form_data_1 = __importDefault(require("form-data"));
-const http = __importStar(require("http"));
-const https = __importStar(require("https"));
-function selectClient(url) {
-    if (url.startsWith('https')) {
-        return https;
-    }
-    return http;
-}
-async function fcTransform(message, raw) {
-    let data = null;
-    if (message.headers['content-type']?.includes('application/json')) {
-        data = JSON.parse(raw);
-    }
-    else if (message.headers['content-type']?.includes('form-data')) {
-        data = null; // await res.formData()
-    }
-    else if (message.headers['content-type']?.includes('octet-stream')) {
-        data = Buffer.from(raw);
-    }
-    else if (message.headers['content-type']?.startsWith('text/')) {
-        data = Buffer.from(raw).toString('utf8');
-    }
-    return {
-        code: message.statusCode || -1,
-        data,
-        headers: message.headers,
-    };
-}
-function bodyTransform(r, headers) {
-    if (!r) {
-        return {
-            headers: headers || {},
-            body: undefined,
-        };
-    }
-    if (r instanceof form_data_1.default) {
-        return {
-            body: r,
-            headers: {
-                ...headers,
-                'content-type': 'multipart/form-data',
-            },
-        };
-    }
-    return {
-        body: JSON.stringify(r),
-        headers: {
-            ...headers,
-            'content-type': 'application/json',
-        },
-    };
-}
-async function makeRequest(url, option, body, config) {
-    return new Promise((resolve) => {
-        let headers = config?.headers || {};
-        let transForm = null;
-        if (body) {
-            let safeHeaders;
-            if (option.headers &&
-                typeof option.headers === 'object' &&
-                !Array.isArray(option.headers)) {
-                safeHeaders = option.headers;
-            }
-            transForm = bodyTransform(body, safeHeaders);
-            headers = {
-                ...headers,
-                ...transForm.headers,
-            };
-        }
-        const req = selectClient(url)
-            .request(url, {
-            headers,
-            ...option,
-        }, (res) => {
-            let data = '';
-            // A chunk of data has been received.
-            res.on('data', (chunk) => {
-                data += chunk;
-            });
-            // The whole response has been received. Print out the result.
-            res.on('end', () => {
-                resolve(fcTransform(res, data));
-            });
-        })
-            .on('error', (err) => {
-            console.log(`Error: ${err.message}`);
-            resolve({
-                code: -1,
-                data: null,
-                headers: {},
-            });
-        });
-        if (transForm && transForm.body) {
-            req.write(transForm.body);
-        }
-        req.end();
-    });
-}
-const NodeCon = {
-    get: async (url, config) => {
-        return makeRequest(url, {}, undefined, config);
-    },
-    post: async (url, body, config) => {
-        return makeRequest(url, {
-            method: 'POST',
-        }, body, config);
-    },
-    patch: async (url, body, config) => {
-        return makeRequest(url, {
-            method: 'PATCH',
-        }, body, config);
-    },
-    delete: async (url, config) => {
-        return makeRequest(url, {
-            method: 'DELETE',
-        }, undefined, config);
-    },
-};
-exports.default = NodeCon;

package/dist/cjs/Swagger/debug/index.d.ts

@@ -1,5 +0,0 @@
-import BaseCon from './BaseCon.js';
-import NodeCon from './NodeCon.js';
-import FetchCon from './FetchCon.js';
-export * from './BaseCon.js';
-export { NodeCon, FetchCon, BaseCon };