@grandlinex/base-con 1.0.0

package/dist/cjs/ConMerger.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ConMerger;
+function ConMerger(conA, conB) {
+    const prop = Object.getPrototypeOf(conB);
+    const propertyNames = Object.getOwnPropertyNames(prop);
+    for (const key of propertyNames) {
+        if (key !== 'constructor' && !conA[key]) {
+            conA[key] = prop[key];
+        }
+    }
+    return conA;
+}

package/dist/cjs/FetchCon.d.ts

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

package/dist/cjs/FetchCon.js

@@ -0,0 +1,79 @@
+"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/NodeCon.d.ts

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

package/dist/cjs/NodeCon.js

@@ -0,0 +1,158 @@
+"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/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+import FormData from 'form-data';
+import BaseCon from './BaseCon.js';
+import ConMerger from './ConMerger.js';
+export * from './BaseCon.js';
+import FetchCon from './FetchCon.js';
+import AxiosCon from './AxiosCon.js';
+export { BaseCon, FormData, FetchCon, AxiosCon, ConMerger };

package/dist/cjs/index.js

@@ -0,0 +1,35 @@
+"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 __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.ConMerger = exports.AxiosCon = exports.FetchCon = exports.FormData = exports.BaseCon = void 0;
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+const form_data_1 = __importDefault(require("form-data"));
+exports.FormData = form_data_1.default;
+const BaseCon_js_1 = __importDefault(require("./BaseCon.js"));
+exports.BaseCon = BaseCon_js_1.default;
+const ConMerger_js_1 = __importDefault(require("./ConMerger.js"));
+exports.ConMerger = ConMerger_js_1.default;
+__exportStar(require("./BaseCon.js"), exports);
+const FetchCon_js_1 = __importDefault(require("./FetchCon.js"));
+exports.FetchCon = FetchCon_js_1.default;
+const AxiosCon_js_1 = __importDefault(require("./AxiosCon.js"));
+exports.AxiosCon = AxiosCon_js_1.default;

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/mjs/AxiosCon.d.ts

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

package/dist/mjs/AxiosCon.js

@@ -0,0 +1,36 @@
+import axios from 'axios';
+async function acTransform(r) {
+    const res = await r;
+    return {
+        code: res.status,
+        data: res.data,
+        headers: res.headers,
+    };
+}
+const AxiosCon = {
+    get: async (url, config) => {
+        return acTransform(axios.get(url, {
+            headers: config?.headers,
+            validateStatus: (status) => true,
+        }));
+    },
+    post: async (url, body, config) => {
+        return acTransform(axios.post(url, body, {
+            headers: config?.headers,
+            validateStatus: (status) => true,
+        }));
+    },
+    patch: async (url, body, config) => {
+        return acTransform(axios.patch(url, body, {
+            headers: config?.headers,
+            validateStatus: (status) => true,
+        }));
+    },
+    delete: async (url, config) => {
+        return acTransform(axios.delete(url, {
+            headers: config?.headers,
+            validateStatus: (status) => true,
+        }));
+    },
+};
+export default AxiosCon;

package/dist/mjs/BaseCon.d.ts

@@ -0,0 +1,182 @@
+/**
+ * THIS FILE IS AUTOMATICALLY GENERATED
+ * DO NOT EDIT THIS FILE
+ */
+export type ErrorType = {
+    type: string;
+    global?: string[];
+    field?: {
+        key: string;
+        message: string;
+    }[];
+};
+export type HeaderType = string | string[] | number | undefined;
+export type HandleRes<T> = {
+    success: boolean;
+    data: T | null;
+    code?: number;
+    error?: ErrorType;
+    headers?: Record<string, HeaderType>;
+};
+export type PathParam = {
+    [key: string]: string | number | undefined;
+};
+export declare function isErrorType(x: any): x is ErrorType;
+export interface ConHandleConfig {
+    headers?: Record<string, string>;
+    param?: PathParam;
+    query?: PathParam;
+}
+export interface ConHandleResponse<T> {
+    code: number;
+    data: T | null;
+    headers: Record<string, HeaderType>;
+}
+export interface ConHandle {
+    get<T>(url: string, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
+    post<T, J>(url: string, body?: J, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
+    patch<T, J>(url: string, body?: J, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
+    delete<T>(url: string, config?: ConHandleConfig): Promise<ConHandleResponse<T>>;
+}
+/**
+ * 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
+ */
+export default class BaseCon {
+    private api;
+    private permanentHeader;
+    private authorization;
+    private noAuth;
+    private disconnected;
+    private readonly logger;
+    con: ConHandle;
+    reconnect: () => Promise<boolean>;
+    onReconnect: (con: BaseCon) => Promise<boolean>;
+    constructor(conf: {
+        con: ConHandle;
+        endpoint: string;
+        logger?: (arg: any) => void;
+        permanentHeader?: Record<string, string>;
+    });
+    /**
+     * Retrieves the API endpoint.
+     *
+     * @return {string} The API endpoint string.
+     */
+    getApiEndpoint(): string;
+    /**
+     * Sets the API endpoint URL used by the client.
+     *
+     * @param {string} endpoint - The full URL of the API endpoint.
+     * @returns {void}
+     */
+    setApiEndpoint(endpoint: string): void;
+    /**
+     * 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(): boolean;
+    /**
+     * Returns the current authorization token.
+     *
+     * @return {string} The authorization token or an empty string if none is set.
+     */
+    token(): string | null;
+    /**
+     * Returns the current authorization token.
+     *
+     * @return {string} The authorization token or an empty string if none is set.
+     */
+    getBearer(): string | null;
+    private p;
+    /**
+     * 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.
+     */
+    ping(): Promise<boolean>;
+    private tokenHeader;
+    setPermanentHeader(header: Record<string, string>): void;
+    /**
+     * 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}.
+     */
+    testToken(): Promise<boolean>;
+    /**
+     * 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`.
+     */
+    connectNoAuth(): Promise<boolean>;
+    /**
+     * Forces a connection using the provided bearer token.
+     *
+     * @param {string|null} token The token to be used for authentication.
+     * @returns {void}
+     */
+    forceConnect(token: string | null): void;
+    coppyFrom(con: BaseCon): void;
+    /**
+     * 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`.
+     */
+    connect(email: string, pw: string, dry?: boolean): Promise<boolean>;
+    /**
+     * 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.
+     */
+    handle<T, J>(type: 'POST' | 'GET' | 'PATCH' | 'DELETE', path: string, body?: J, config?: ConHandleConfig): Promise<HandleRes<T>>;
+}