@grandlinex/swagger-mate 1.3.2 → 1.3.4

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

@@ -20,6 +20,16 @@ function isErrorType(x) {
  * @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;
@@ -27,6 +37,7 @@ class BaseCon {
         this.noAuth = false;
         this.authorization = null;
         this.con = conf.con;
+        this.permanentHeader = conf.permanentHeader || {};
         this.reconnect = async () => {
             this.disconnected = true;
             return false;
@@ -64,12 +75,23 @@ class BaseCon {
         return (this.noAuth || this.authorization !== null) && !this.disconnected;
     }
     /**
-     * Returns the current authorization token.
+     * Retrieves the current authorization token.
      *
-     * @return {string} The authorization token or an empty string if none is set.
+     * @return {string|null} The token string used for authorization, or {@code null} if no token is set.
      */
     token() {
-        return this.authorization || '';
+        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;
@@ -108,6 +130,27 @@ class BaseCon {
             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
@@ -126,9 +169,7 @@ class BaseCon {
         if (ping) {
             try {
                 const con = await this.con.get(this.p('/test/auth'), {
-                    headers: {
-                        Authorization: this.token(),
-                    },
+                    headers: this.tokenHeader(),
                 });
                 return con.code === 200 || con.code === 201;
             }
@@ -163,18 +204,29 @@ class BaseCon {
         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} token The token to be used for authentication.
+     * @param {string|null} token The token to be used for authentication.
      * @returns {void}
      */
-    forceConnectWithToken(token) {
-        this.authorization = `Bearer ${token}`;
+    forceConnect(token) {
+        if (token) {
+            this.authorization = token.replace('Bearer ', '').replace('bearer ', '');
+        }
+        else {
+            this.authorization = null;
+        }
         this.disconnected = false;
-        this.noAuth = 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.
@@ -202,7 +254,7 @@ class BaseCon {
                 });
                 if (token.code === 200 || token.code === 201) {
                     if (!dry) {
-                        this.authorization = `Bearer ${token.data?.token}`;
+                        this.authorization = token.data.token;
                         this.disconnected = false;
                         this.noAuth = false;
                         this.reconnect = async () => {
@@ -267,7 +319,7 @@ class BaseCon {
                 dat = await this.con.get(this.p(path, config), {
                     ...config,
                     headers: {
-                        Authorization: this.token(),
+                        ...this.tokenHeader(),
                         ...formHeader,
                         ...config?.headers,
                         ...this.permanentHeader,
@@ -278,7 +330,7 @@ class BaseCon {
                 dat = await this.con.post(this.p(path, config), body, {
                     ...config,
                     headers: {
-                        Authorization: this.token(),
+                        ...this.tokenHeader(),
                         ...formHeader,
                         ...config?.headers,
                         ...this.permanentHeader,
@@ -289,7 +341,7 @@ class BaseCon {
                 dat = await this.con.patch(this.p(path, config), body, {
                     ...config,
                     headers: {
-                        Authorization: this.token(),
+                        ...this.tokenHeader(),
                         ...formHeader,
                         ...config?.headers,
                         ...this.permanentHeader,
@@ -300,7 +352,7 @@ class BaseCon {
                 dat = await this.con.delete(this.p(path, config), {
                     ...config,
                     headers: {
-                        Authorization: this.token(),
+                        ...this.tokenHeader(),
                         ...formHeader,
                         ...config?.headers,
                         ...this.permanentHeader,

package/dist/cjs/index.d.ts

@@ -1,6 +1,7 @@
 import SwaggerUtil from './Swagger/SwaggerUtil.js';
 import SPathUtil from './Swagger/Path/SPathUtil.js';
 import SwaggerClient from './Swagger/Client/SwaggerClient.js';
+export * from './Swagger/Path/ESchemaEditor.js';
 export * from './Swagger/debug/index.js';
 export * from './Swagger/annotation/index.js';
 export * from './Swagger/Meta/Swagger.js';

package/dist/cjs/index.js

@@ -24,6 +24,7 @@ const SPathUtil_js_1 = __importDefault(require("./Swagger/Path/SPathUtil.js"));
 exports.SPathUtil = SPathUtil_js_1.default;
 const SwaggerClient_js_1 = __importDefault(require("./Swagger/Client/SwaggerClient.js"));
 exports.SwaggerClient = SwaggerClient_js_1.default;
+__exportStar(require("./Swagger/Path/ESchemaEditor.js"), exports);
 __exportStar(require("./Swagger/debug/index.js"), exports);
 __exportStar(require("./Swagger/annotation/index.js"), exports);
 __exportStar(require("./Swagger/Meta/Swagger.js"), exports);

package/dist/mjs/Swagger/Meta/SwaggerTypes.d.ts

@@ -56,7 +56,7 @@ export interface SwaggerRInfo {
     version: string;
     license?: SwaggerRInfoLicence;
 }
-export type SSchemaEl = {
+export type SSchemaElObj = {
     type: SDataType;
     example?: string;
     format?: SDataFormat;
@@ -68,7 +68,8 @@ export type SSchemaEl = {
     required?: string[];
     enum?: string[];
     nullable?: boolean;
-} | SwaggerRRef;
+};
+export type SSchemaEl = SSchemaElObj | SwaggerRRef;
 export type SwaggerContent = {
     [K in SMediaType]?: {
         schema: SSchemaEl;

package/dist/mjs/Swagger/Path/ESchemaEditor.d.ts

@@ -0,0 +1,51 @@
+import { CoreEntity } from '@grandlinex/core';
+import { SKey, SSchemaEl, SSchemaElObj } from '../Meta/SwaggerTypes.js';
+export type ESchemaAddOption = {
+    key: string;
+    list?: boolean;
+    entity?: CoreEntity;
+    schema?: SSchemaEl;
+    required?: boolean;
+    nullable?: boolean;
+};
+export declare class ESchemaEditor<T extends CoreEntity> {
+    private data;
+    private name;
+    private constructor();
+    /**
+     * Removes the specified keys from the schema's properties and updates the required list.
+     *
+     * @param {...(keyof T)} keys - The keys of the properties to remove.
+     * @returns {ESchemaEditor<T>} The editor instance for method chaining.
+     */
+    remove(...keys: (keyof T)[]): ESchemaEditor<T>;
+    /**
+     * Adds properties to the schema based on the provided options.
+     *
+     * @param {...ESchemaAddOption} options The options describing the properties to add. Each option may specify a
+     *   `key`, a `schema` or an `entity`, and optionally whether the property is a `list`, `nullable`, or `required`.
+     * @returns {ESchemaEditor<T>} The editor instance for chaining.
+     */
+    add(...options: ESchemaAddOption[]): ESchemaEditor<T>;
+    getSchema(): SSchemaElObj;
+    getSKeySchema(): SKey<SSchemaElObj>;
+    static fromEntity<J extends CoreEntity>(e: J): ESchemaEditor<J>;
+    /**
+     * Generates a JSON schema representation from a CoreEntity instance.
+     *
+     * This method inspects the entity's metadata to construct a schema object
+     * describing the entity's shape. The resulting schema contains:
+     * - `type`: always `"object"`.
+     * - `description`: a string indicating the entity name.
+     * - `required`: an array of property names that are defined on the entity.
+     * - `properties`: an object mapping each property name to an object that
+     *   includes the resolved database type and its nullability.
+     *
+     * If no metadata is found for the provided entity, the method returns `undefined`.
+     *
+     * @param {T} entity - The entity instance for which to create a schema.
+     * @returns {SSchemaElObj | undefined} The generated schema object, or `undefined`
+     *          if the entity's metadata could not be retrieved.
+     */
+    static schemaFromEntity<T extends CoreEntity>(entity: T): SSchemaElObj | undefined;
+}

package/dist/mjs/Swagger/Path/ESchemaEditor.js

@@ -0,0 +1,147 @@
+import { getColumnMeta, getEntityMeta, } from '@grandlinex/core';
+function resolveDBType(dType) {
+    switch (dType) {
+        case 'int':
+        case 'long':
+            return 'integer';
+        case 'double':
+        case 'float':
+            return 'number';
+        case 'blob':
+            return 'string';
+        case 'string':
+        case 'text':
+        case 'uuid':
+            return 'string';
+        case 'boolean':
+            return 'boolean';
+        case 'date':
+            return 'string';
+        case 'json':
+            return 'object';
+        default:
+            throw Error('TypeNotSupported');
+    }
+}
+export class ESchemaEditor {
+    constructor(entity, name) {
+        this.data = ESchemaEditor.schemaFromEntity(entity);
+        this.name = name;
+    }
+    /**
+     * Removes the specified keys from the schema's properties and updates the required list.
+     *
+     * @param {...(keyof T)} keys - The keys of the properties to remove.
+     * @returns {ESchemaEditor<T>} The editor instance for method chaining.
+     */
+    remove(...keys) {
+        if (this.data.properties) {
+            for (const key of keys) {
+                this.data.properties = Object.fromEntries(Object.entries(this.data.properties).filter(([e]) => key !== e));
+                this.data.required = (this.data.required || []).filter((e) => key !== e);
+            }
+        }
+        return this;
+    }
+    /**
+     * Adds properties to the schema based on the provided options.
+     *
+     * @param {...ESchemaAddOption} options The options describing the properties to add. Each option may specify a
+     *   `key`, a `schema` or an `entity`, and optionally whether the property is a `list`, `nullable`, or `required`.
+     * @returns {ESchemaEditor<T>} The editor instance for chaining.
+     */
+    add(...options) {
+        if (!this.data.properties) {
+            return this;
+        }
+        for (const option of options) {
+            if (option.schema) {
+                if (option.list) {
+                    this.data.properties[option.key] = {
+                        type: 'array',
+                        items: option.schema,
+                        nullable: option.nullable,
+                    };
+                }
+                else {
+                    this.data.properties[option.key] = option.schema;
+                }
+            }
+            else if (option.entity) {
+                const scheme = ESchemaEditor.fromEntity(option.entity).getSchema();
+                if (option.nullable) {
+                    scheme.nullable = true;
+                }
+                if (option.list) {
+                    this.data.properties[option.key] = {
+                        type: 'array',
+                        items: scheme,
+                    };
+                }
+                else {
+                    this.data.properties[option.key] = scheme;
+                }
+            }
+            if (option.required) {
+                this.data.required = [...(this.data.required || []), option.key];
+            }
+        }
+        return this;
+    }
+    getSchema() {
+        return this.data;
+    }
+    getSKeySchema() {
+        return {
+            [this.name]: this.data,
+        };
+    }
+    static fromEntity(e) {
+        const meta = getEntityMeta(e);
+        if (meta) {
+            return new ESchemaEditor(e, meta.name);
+        }
+        throw new Error('Entity metadata not found');
+    }
+    /**
+     * Generates a JSON schema representation from a CoreEntity instance.
+     *
+     * This method inspects the entity's metadata to construct a schema object
+     * describing the entity's shape. The resulting schema contains:
+     * - `type`: always `"object"`.
+     * - `description`: a string indicating the entity name.
+     * - `required`: an array of property names that are defined on the entity.
+     * - `properties`: an object mapping each property name to an object that
+     *   includes the resolved database type and its nullability.
+     *
+     * If no metadata is found for the provided entity, the method returns `undefined`.
+     *
+     * @param {T} entity - The entity instance for which to create a schema.
+     * @returns {SSchemaElObj | undefined} The generated schema object, or `undefined`
+     *          if the entity's metadata could not be retrieved.
+     */
+    static schemaFromEntity(entity) {
+        const schema = {
+            type: 'object',
+            properties: {},
+        };
+        const meta = getEntityMeta(entity);
+        if (!meta) {
+            return undefined;
+        }
+        schema.description = `Entity: ${meta.name}`;
+        schema.required = [];
+        const keys = Object.keys(entity);
+        keys.forEach((k) => {
+            const cMeta = getColumnMeta(entity, k);
+            if (cMeta && schema.properties) {
+                schema.required.push(k);
+                schema.properties[k] = {
+                    type: resolveDBType(cMeta.dataType),
+                    nullable: cMeta.canBeNull,
+                };
+            }
+        });
+        return schema;
+    }
+}

package/dist/mjs/Swagger/Path/SPathUtil.d.ts

@@ -1,6 +1,7 @@
 import { CoreEntity } from '@grandlinex/core';
 import { HttpStatusTypes } from '../Meta/SwaggerTypesStatic.js';
-import { SKey, SSchemaEl, SwaggerContent, SwaggerRPathConfResponse, SwaggerRPathReqBody } from '../Meta/SwaggerTypes.js';
+import { SKey, SSchemaEl, SSchemaElObj, SwaggerContent, SwaggerRPathConfResponse, SwaggerRPathReqBody } from '../Meta/SwaggerTypes.js';
+import { ESchemaEditor } from './ESchemaEditor.js';
 export default class SPathUtil {
     /**
      * Generates a default response mapping for the specified HTTP status types.
@@ -90,10 +91,11 @@ export default class SPathUtil {
      * If no metadata is found for the provided entity, the method returns `undefined`.
      *
      * @param {T} entity - The entity instance for which to create a schema.
-     * @returns {SSchemaEl | undefined} The generated schema object, or `undefined`
+     * @returns {SSchemaElObj | undefined} The generated schema object, or `undefined`
      *          if the entity's metadata could not be retrieved.
+     * @deprecated Use {@link ESchemaEditor.schemaFromEntity} instead.
      */
-    static schemaFromEntity<T extends CoreEntity>(entity: T): SSchemaEl | undefined;
+    static schemaFromEntity<T extends CoreEntity>(entity: T): SSchemaElObj | undefined;
     /**
      * Generates a content schema object for the given entity. The schema contains a description derived from the entity metadata and a JSON content schema based on the entity's structure.
      *
@@ -114,7 +116,7 @@ export default class SPathUtil {
      * @param {CoreEntity[]} e The entities for which schema entries should be generated.
      * @return {SKey<SSchemaEl>} An object whose keys are entity names and values are the schemas derived from those entities.
      */
-    static schemaEntryGen(...e: CoreEntity[]): SKey<SSchemaEl>;
+    static schemaEntryGen(...e: CoreEntity[]): SKey<SSchemaElObj>;
     /**
      * Builds a JSON schema representation for an entity view that includes both the
      * entity data and its related entity map.
@@ -124,76 +126,5 @@ export default class SPathUtil {
      * @returns A {@link SSchemaEl} object schema with properties `i`, `dat`, and `join_map`.
      */
     static schemaFromEntityView<A extends CoreEntity, B extends CoreEntity>(entity: A, entityMap: B): SSchemaEl;
-    /**
-     * Extends an entity schema object by merging additional schema options.
-     *
-     * @param {CoreEntity} entity
-     *   The entity for which the schema should be extended.
-     *
-     * @param {...Object} options
-     *   One or more objects defining schema extensions. Each object may contain:
-     *   - `key` (string): The property key to add or extend.
-     *   - `list` (boolean, optional): Indicates whether the property is a list.
-     *   - `entity` (CoreEntity, optional): The entity type for the property.
-     *   - `schema` (SSchemaEl, optional): A custom schema definition for the property.
-     *   - `required` (boolean, optional): Whether the property is required.
-     *
-     * @return {SSchemaEl}
-     *   The resulting schema element. If a single property is returned by
-     *   `extendEntitySchema`, its schema is returned directly; otherwise an
-     *   object schema with a type of `'object'` is returned.
-     */
-    static extendEntitySchemaObject(entity: CoreEntity, ...options: {
-        key: string;
-        list?: boolean;
-        entity?: CoreEntity;
-        schema?: SSchemaEl;
-        required?: boolean;
-    }[]): SSchemaEl;
-    /**
-     * Extends the schema of a given {@link CoreEntity} with additional properties.
-     *
-     * @param {CoreEntity} entity
-     *   The entity whose schema will be extended.
-     *
-     * @param {...{
-     *   key: string,
-     *   list?: boolean,
-     *   entity?: CoreEntity,
-     *   schema?: SSchemaEl,
-     *   required?: boolean
-     * }} options
-     *   One or more option objects specifying the extensions to apply. Each option
-     *   may provide either a direct schema (`schema`) or an entity reference
-     *   (`entity`). The `list` flag indicates whether the property should be
-     *   represented as an array of the provided schema. The `required` flag
-     *   adds the property to the schema’s required list.
-     *
-     * @returns {SKey<SSchemaEl>}
-     *   An object containing the updated schema for the entity, keyed by the
-     *   entity’s name. If the entity metadata cannot be found, an empty
-     *   object is returned.
-     */
-    static extendEntitySchema(entity: CoreEntity, ...options: {
-        key: string;
-        list?: boolean;
-        entity?: CoreEntity;
-        schema?: SSchemaEl;
-        required?: boolean;
-    }[]): SKey<SSchemaEl>;
-    /**
-     * Reduces the entity schema to a single schema element or a generic object.
-     *
-     * @param entity The entity whose schema should be reduced.
-     * @param keys Optional list of keys to include in the reduced schema. If omitted, all keys are considered.
-     * @return Returns the schema element of the sole key if only one key is present; otherwise, returns a generic object schema with type `'object'`. */
-    static reduceEntitySchemaObject<T extends CoreEntity>(entity: T, ...keys: (keyof T)[]): SSchemaEl;
-    /**
-     * Creates a reduced version of an entity's schema by excluding specified properties.
-     *
-     * @param {CoreEntity} entity - The entity whose schema is to be processed.
-     * @param {...string} keys - Property names to remove from the schema's `properties` and `required` lists.
-     *
-     * @returns */
-    static reduceEntitySchema<T extends CoreEntity>(entity: T, ...keys: (keyof T)[]): SKey<SSchemaEl>;
+    static editor<J extends CoreEntity>(e: J): ESchemaEditor<J>;
 }