@grandlinex/swagger-mate 1.3.1 → 1.3.3

package/dist/cjs/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/cjs/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/cjs/Swagger/Path/ESchemaEditor.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ESchemaEditor = void 0;
+const core_1 = require("@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');
+    }
+}
+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 = (0, core_1.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 = (0, core_1.getEntityMeta)(entity);
+        if (!meta) {
+            return undefined;
+        }
+        schema.description = `Entity: ${meta.name}`;
+        schema.required = [];
+        const keys = Object.keys(entity);
+        keys.forEach((k) => {
+            const cMeta = (0, core_1.getColumnMeta)(entity, k);
+            if (cMeta && schema.properties) {
+                schema.required.push(k);
+                schema.properties[k] = {
+                    type: resolveDBType(cMeta.dataType),
+                    nullable: cMeta.canBeNull,
+                };
+            }
+        });
+        return schema;
+    }
+}
+exports.ESchemaEditor = ESchemaEditor;

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

@@ -1,16 +1,107 @@
 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.
+     *
+     * @param {HttpStatusTypes[]} types - The HTTP status types for which default responses should be created.
+     * @return {SwaggerRPathConfResponse} An object mapping each provided status type to its default response definition. */
     static defaultResponse(...types: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    /**
+     * Creates a request body definition for JSON content type using the provided schema.
+     *
+     * @param {SSchemaEl} schema - The JSON schema used for validating the request body.
+     * @return {SwaggerRPathReqBody} A Swagger path request body object specifying application/json content type with the provided schema.
+     */
     static jsonBody(schema: SSchemaEl): SwaggerRPathReqBody;
+    /**
+     * Builds a Swagger request body for `multipart/form-data` requests.
+     *
+     * @param {SSchemaEl} [schema] Optional schema describing the form data.
+     *        If omitted, a default schema with a single binary `file` field is provided.
+     * @return {SwaggerRPathReqBody} Swagger request body definition with
+     *         `multipart/form-data` content and the supplied or default schema. */
     static formBody(schema?: SSchemaEl): SwaggerRPathReqBody;
+    /**
+     * Generates a Swagger content definition for the provided entity.
+     *
+     * @param {T} entity - The entity instance to derive the Swagger schema from.
+     * @param {boolean} [list] - When true, the schema will be wrapped in an array type, representing a list of entities.
+     *
+     * @returns {SwaggerContent|undefined} The Swagger content object for the entity, or `undefined` if the entity does not have a schema.
+     */
     static entityContent<T extends CoreEntity>(entity: T, list?: boolean): SwaggerContent | undefined;
+    /**
+     * @template T extends CoreEntity
+     * @param {T} entity - The entity instance for which to build the response configuration.
+     * @param {boolean} [list] - Indicates whether the response should represent a list of entities.
+     * @param {boolean} [create] - Indicates whether the response corresponds to a creation operation (status code 201); otherwise 200.
+     * @returns {SwaggerRPathConfResponse} The Swagger response configuration object containing the appropriate status code and content.
+     */
     static entityResponse<T extends CoreEntity>(entity: T, list?: boolean, create?: boolean): SwaggerRPathConfResponse;
+    /**
+     * Builds a JSON schema reference path for the given component name.
+     *
+     * @param {string} inp - The name of the schema component.
+     * @return {string} The JSON reference path formatted as `#/components/schemas/<inp>`.
+     */
     static schemaPath(inp: string): string;
+    /**
+     * Creates a Swagger request body definition that references a schema.
+     *
+     * @param {string | CoreEntity} $ref
+     *   Either the string reference to a schema or a `CoreEntity` instance whose
+     *   class name will be used to build the reference path.
+     * @param {boolean} list
+     *   If true, the referenced schema is wrapped in an array; otherwise the
+     *   schema is used directly.
+     * @returns {SwaggerRPathReqBody}
+     *   The request body object containing the appropriate content and schema
+     *   configuration.
+     */
+    static refRequest($ref: string | CoreEntity, list: boolean): SwaggerRPathReqBody;
+    /**
+     * Creates a Swagger response configuration for a given HTTP status code.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for */
     static refResponse(code: HttpStatusTypes, $ref: string | CoreEntity, list: boolean, ...addCodes: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    /**
+     * Builds a Swagger response configuration object for a given HTTP status code and schema.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for the response.
+     * @param {SSchemaEl} schema - The JSON schema definition for the response body.
+     * @param {boolean} list - If true, the schema is wrapped in an array for list responses.
+     * @param {...HttpStatusTypes} addCodes - Additional HTTP status codes for default responses.
+     * @return {SwaggerRPathConfResponse} The constructed response configuration object.
+     */
     static jsonResponse(code: HttpStatusTypes, schema: SSchemaEl, list: boolean, ...addCodes: HttpStatusTypes[]): SwaggerRPathConfResponse;
-    static schemaFromEntity<T extends CoreEntity>(entity: T): SSchemaEl | undefined;
+    /**
+     * 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.
+     * @deprecated Use {@link ESchemaEditor.schemaFromEntity} instead.
+     */
+    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.
+     *
+     * @param {T} entity - The entity instance for which to generate the content schema. The generic type `T` must extend {@link CoreEntity}.
+     * @returns {{ description: string; content: { 'application/json': { schema: SSchemaEl } }; } | undefined} An object containing the content schema, or `undefined` if no metadata is available for the entity.
+     */
     static contentSchemaFromEntity<T extends CoreEntity>(entity: T): {
         description: string;
         content: {
@@ -20,9 +111,20 @@ export default class SPathUtil {
         };
     } | undefined;
     /**
-     * generate global schema
-     * @param e
+     * Generates a mapping from entity names to their corresponding schema objects.
+     *
+     * @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<SSchemaElObj>;
+    /**
+     * Builds a JSON schema representation for an entity view that includes both the
+     * entity data and its related entity map.
+     *
+     * @param entity The primary entity used to construct the `dat` portion of the schema.
+     * @param entityMap The related entity map used to construct the `join_map` portion of the schema.
+     * @returns A {@link SSchemaEl} object schema with properties `i`, `dat`, and `join_map`.
      */
-    static schemaEntryGen(...e: CoreEntity[]): SKey<SSchemaEl>;
     static schemaFromEntityView<A extends CoreEntity, B extends CoreEntity>(entity: A, entityMap: B): SSchemaEl;
+    static editor<J extends CoreEntity>(e: J): ESchemaEditor<J>;
 }

package/dist/cjs/Swagger/Path/SPathUtil.js

@@ -5,31 +5,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@grandlinex/core");
 const SUtilMap_js_1 = __importDefault(require("./SUtilMap.js"));
-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');
-    }
-}
+const ESchemaEditor_js_1 = require("./ESchemaEditor.js");
 class SPathUtil {
+    /**
+     * Generates a default response mapping for the specified HTTP status types.
+     *
+     * @param {HttpStatusTypes[]} types - The HTTP status types for which default responses should be created.
+     * @return {SwaggerRPathConfResponse} An object mapping each provided status type to its default response definition. */
     static defaultResponse(...types) {
         const res = {};
         types.forEach((el) => {
@@ -37,6 +19,12 @@ class SPathUtil {
         });
         return res;
     }
+    /**
+     * Creates a request body definition for JSON content type using the provided schema.
+     *
+     * @param {SSchemaEl} schema - The JSON schema used for validating the request body.
+     * @return {SwaggerRPathReqBody} A Swagger path request body object specifying application/json content type with the provided schema.
+     */
     static jsonBody(schema) {
         return {
             content: {
@@ -46,6 +34,13 @@ class SPathUtil {
             },
         };
     }
+    /**
+     * Builds a Swagger request body for `multipart/form-data` requests.
+     *
+     * @param {SSchemaEl} [schema] Optional schema describing the form data.
+     *        If omitted, a default schema with a single binary `file` field is provided.
+     * @return {SwaggerRPathReqBody} Swagger request body definition with
+     *         `multipart/form-data` content and the supplied or default schema. */
     static formBody(schema) {
         return {
             content: {
@@ -64,6 +59,14 @@ class SPathUtil {
             },
         };
     }
+    /**
+     * Generates a Swagger content definition for the provided entity.
+     *
+     * @param {T} entity - The entity instance to derive the Swagger schema from.
+     * @param {boolean} [list] - When true, the schema will be wrapped in an array type, representing a list of entities.
+     *
+     * @returns {SwaggerContent|undefined} The Swagger content object for the entity, or `undefined` if the entity does not have a schema.
+     */
     static entityContent(entity, list) {
         const schema = this.schemaFromEntity(entity);
         if (!schema) {
@@ -85,6 +88,13 @@ class SPathUtil {
             },
         };
     }
+    /**
+     * @template T extends CoreEntity
+     * @param {T} entity - The entity instance for which to build the response configuration.
+     * @param {boolean} [list] - Indicates whether the response should represent a list of entities.
+     * @param {boolean} [create] - Indicates whether the response corresponds to a creation operation (status code 201); otherwise 200.
+     * @returns {SwaggerRPathConfResponse} The Swagger response configuration object containing the appropriate status code and content.
+     */
     static entityResponse(entity, list, create) {
         const code = create ? '201' : '200';
         const an = {};
@@ -94,9 +104,58 @@ class SPathUtil {
         };
         return an;
     }
+    /**
+     * Builds a JSON schema reference path for the given component name.
+     *
+     * @param {string} inp - The name of the schema component.
+     * @return {string} The JSON reference path formatted as `#/components/schemas/<inp>`.
+     */
     static schemaPath(inp) {
         return `#/components/schemas/${inp}`;
     }
+    /**
+     * Creates a Swagger request body definition that references a schema.
+     *
+     * @param {string | CoreEntity} $ref
+     *   Either the string reference to a schema or a `CoreEntity` instance whose
+     *   class name will be used to build the reference path.
+     * @param {boolean} list
+     *   If true, the referenced schema is wrapped in an array; otherwise the
+     *   schema is used directly.
+     * @returns {SwaggerRPathReqBody}
+     *   The request body object containing the appropriate content and schema
+     *   configuration.
+     */
+    static refRequest($ref, list) {
+        const t = typeof $ref === 'string'
+            ? { $ref }
+            : {
+                $ref: this.schemaPath(core_1.XUtil.getEntityNames($ref).className),
+            };
+        if (list) {
+            return {
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'array',
+                            items: t,
+                        },
+                    },
+                },
+            };
+        }
+        return {
+            content: {
+                'application/json': {
+                    schema: t,
+                },
+            },
+        };
+    }
+    /**
+     * Creates a Swagger response configuration for a given HTTP status code.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for */
     static refResponse(code, $ref, list, ...addCodes) {
         const an = {
             ...this.defaultResponse(...addCodes),
@@ -131,6 +190,15 @@ class SPathUtil {
         }
         return an;
     }
+    /**
+     * Builds a Swagger response configuration object for a given HTTP status code and schema.
+     *
+     * @param {HttpStatusTypes} code - The primary HTTP status code for the response.
+     * @param {SSchemaEl} schema - The JSON schema definition for the response body.
+     * @param {boolean} list - If true, the schema is wrapped in an array for list responses.
+     * @param {...HttpStatusTypes} addCodes - Additional HTTP status codes for default responses.
+     * @return {SwaggerRPathConfResponse} The constructed response configuration object.
+     */
     static jsonResponse(code, schema, list, ...addCodes) {
         const an = {
             ...this.defaultResponse(...addCodes),
@@ -160,30 +228,33 @@ class SPathUtil {
         }
         return an;
     }
+    /**
+     * 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.
+     * @deprecated Use {@link ESchemaEditor.schemaFromEntity} instead.
+     */
     static schemaFromEntity(entity) {
-        const schema = {
-            type: 'object',
-            properties: {},
-        };
-        const meta = (0, core_1.getEntityMeta)(entity);
-        if (!meta) {
-            return undefined;
-        }
-        schema.description = `Entity: ${meta.name}`;
-        schema.required = [];
-        const keys = Object.keys(entity);
-        keys.forEach((k) => {
-            const cMeta = (0, core_1.getColumnMeta)(entity, k);
-            if (cMeta && schema.properties) {
-                schema.required.push(k);
-                schema.properties[k] = {
-                    type: resolveDBType(cMeta.dataType),
-                    nullable: cMeta.canBeNull,
-                };
-            }
-        });
-        return schema;
+        return ESchemaEditor_js_1.ESchemaEditor.schemaFromEntity(entity);
     }
+    /**
+     * 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.
+     *
+     * @param {T} entity - The entity instance for which to generate the content schema. The generic type `T` must extend {@link CoreEntity}.
+     * @returns {{ description: string; content: { 'application/json': { schema: SSchemaEl } }; } | undefined} An object containing the content schema, or `undefined` if no metadata is available for the entity.
+     */
     static contentSchemaFromEntity(entity) {
         const meta = (0, core_1.getEntityMeta)(entity);
         if (!meta) {
@@ -193,25 +264,35 @@ class SPathUtil {
             description: `Entity: ${meta.name}`,
             content: {
                 'application/json': {
-                    schema: this.schemaFromEntity(entity),
+                    schema: ESchemaEditor_js_1.ESchemaEditor.schemaFromEntity(entity),
                 },
             },
         };
     }
     /**
-     * generate global schema
-     * @param e
+     * Generates a mapping from entity names to their corresponding schema objects.
+     *
+     * @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) {
         const out = {};
         e.forEach((el) => {
             const meta = (0, core_1.getEntityMeta)(el);
             if (meta) {
-                out[meta.name] = SPathUtil.schemaFromEntity(el);
+                out[meta.name] = ESchemaEditor_js_1.ESchemaEditor.schemaFromEntity(el);
             }
         });
         return out;
     }
+    /**
+     * Builds a JSON schema representation for an entity view that includes both the
+     * entity data and its related entity map.
+     *
+     * @param entity The primary entity used to construct the `dat` portion of the schema.
+     * @param entityMap The related entity map used to construct the `join_map` portion of the schema.
+     * @returns A {@link SSchemaEl} object schema with properties `i`, `dat`, and `join_map`.
+     */
     static schemaFromEntityView(entity, entityMap) {
         return {
             type: 'object',
@@ -219,10 +300,13 @@ class SPathUtil {
                 i: {
                     type: 'integer',
                 },
-                dat: this.schemaFromEntity(entity),
-                join_map: this.schemaFromEntity(entityMap),
+                dat: ESchemaEditor_js_1.ESchemaEditor.schemaFromEntity(entity),
+                join_map: ESchemaEditor_js_1.ESchemaEditor.schemaFromEntity(entityMap),
             },
         };
     }
+    static editor(e) {
+        return ESchemaEditor_js_1.ESchemaEditor.fromEntity(e);
+    }
 }
 exports.default = SPathUtil;

package/dist/cjs/Swagger/SwaggerUtil.d.ts

@@ -1,11 +1,27 @@
-import { ObjectLike } from '@grandlinex/core';
+import { CoreLogChannel, ObjectLike } from '@grandlinex/core';
 import { Server } from 'net';
 import { MergeInputType, SwaggerConfig, SwaggerRPath } from './Meta/SwaggerTypes.js';
 import { RouteData } from './annotation/index.js';
 export default class SwaggerUtil {
+    static logger: CoreLogChannel | null;
+    static getLogger(): CoreLogChannel;
     static writeMeta(conf: SwaggerConfig, kind: 'JSON' | 'YAML', path?: string): void;
     static readMeta(path: string): any;
-    static serveMeta(conf: SwaggerConfig, port?: number, auth?: string): Promise<Server | null>;
+    /**
+     * Serves a meta page for Swagger UI or rapi-doc.
+     *
+     * @param {SwaggerConfig} conf The swagger configuration to expose via `/spec`.
+     * @param {Object} [option] Options for serving the meta page.
+     * @param {'swagger-ui'|'rapi-doc'} [option.type='swagger-ui'] The type of UI to serve.
+     * @param {number} [option.port] The port to listen on. Defaults to 9000.
+     * @param {string} [option.auth] Optional authentication key appended to the URL.
+     * @returns {Promise<Server|null>} A promise that resolves with the created server instance or null.
+     */
+    static serveMeta(conf: SwaggerConfig, option?: {
+        type?: 'swagger-ui' | 'rapi-doc';
+        port?: number;
+        auth?: string;
+    }): Promise<Server | null>;
     static metaExtractor(root: ObjectLike, npmPackageVersion: boolean, ...path: ObjectLike[]): SwaggerConfig | undefined;
     static routeToSwaggerPath(route: RouteData): SwaggerRPath;
     static merge(root: SwaggerConfig, data: MergeInputType[]): SwaggerConfig;