@grandlinex/swagger-mate 0.30.8

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

@@ -0,0 +1,107 @@
+import { HttpStatusTypes, SDataFormat, SDataType, SMediaType } from './SwaggerTypesStatic.js';
+export type SwaggerPathInput = {
+    path: SwaggerRPath;
+    prefix?: string;
+};
+export type SwaggerRRef = {
+    $ref: string;
+};
+export declare function isSwaggerRef(o: unknown): o is SwaggerRRef;
+export type SwaggerRPathConfResponseDef = SwaggerCompResponse | SwaggerRRef;
+export type SwaggerRPath = SKey<SwaggerRPathTypes>;
+export type SwaggerRPathConfResponse = {
+    [K in HttpStatusTypes]?: SwaggerRPathConfResponseDef;
+};
+export interface SwaggerRPathReqBody {
+    content?: SwaggerContent;
+    description?: string;
+}
+export interface SwaggerRPathParameter {
+    content?: SwaggerContent;
+    description?: string;
+    name: string;
+    required: boolean;
+    schema?: SSchemaEl;
+    in?: 'query' | 'header' | 'path';
+}
+export interface SwaggerRPathConf {
+    responses?: SwaggerRPathConfResponse;
+    description?: string;
+    summary?: string;
+    tags?: string[];
+    operationId?: string;
+    requestBody?: SwaggerRPathReqBody;
+    parameters?: SwaggerRPathParameter[];
+}
+export interface SwaggerRPathTypes {
+    get?: SwaggerRPathConf;
+    post?: SwaggerRPathConf;
+    patch?: SwaggerRPathConf;
+    delete?: SwaggerRPathConf;
+    update?: SwaggerRPathConf;
+}
+export interface SwaggerRInfoLicence {
+    name: string;
+    url?: string;
+}
+export interface SwaggerRServer {
+    url: string;
+    description?: string;
+    variables?: string | string[];
+}
+export interface SwaggerRInfo {
+    title: string;
+    description?: string;
+    termsOfService?: string;
+    version: string;
+    license?: SwaggerRInfoLicence;
+}
+export type SSchemaEl = {
+    type: SDataType;
+    example?: string;
+    format?: SDataFormat;
+    description?: string;
+    properties?: {
+        [key: string]: SSchemaEl;
+    };
+    items?: SSchemaEl;
+    required?: string[];
+    enum?: string[];
+} | SwaggerRRef;
+export type SwaggerContent = {
+    [K in SMediaType]?: {
+        schema: SSchemaEl;
+    };
+};
+export type SwaggerCompResponse = {
+    description?: string;
+    content?: SwaggerContent;
+};
+export type SwaggerComSecuritySchemes = {
+    in?: 'query' | 'header' | 'cookie';
+    scheme: string;
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
+    bearerFormat?: string | 'JWT';
+    description?: string;
+};
+export interface SKey<T> {
+    [key: string]: T;
+}
+export interface SwaggerConfigComponents {
+    securitySchemes?: SKey<SwaggerComSecuritySchemes>;
+    responses?: SKey<SwaggerCompResponse>;
+    schemas?: SKey<SSchemaEl>;
+}
+export interface SwaggerConfig {
+    openapi: string;
+    info: SwaggerRInfo;
+    servers?: SwaggerRServer[];
+    paths: SwaggerRPath;
+    security?: [SKey<any[]>];
+    tags?: string[];
+    components?: SwaggerConfigComponents;
+}
+export interface MergeInputType {
+    path: SwaggerPathInput | undefined;
+    comp: SwaggerConfigComponents | undefined;
+}

package/dist/mjs/Swagger/Meta/SwaggerTypes.js

@@ -0,0 +1,5 @@
+/* eslint-disable @typescript-eslint/ban-types */
+export function isSwaggerRef(o) {
+    const a = o;
+    return typeof a === 'object' && !!a?.$ref;
+}

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

@@ -0,0 +1,4 @@
+export type SMediaType = 'text/plain; charset=utf-8' | 'application/json' | 'multipart/form-data';
+export type SDataFormat = 'binary' | 'base64' | 'uuid';
+export type SDataType = 'integer' | 'number' | 'string' | 'boolean' | 'array' | 'object';
+export type HttpStatusTypes = '100' | '101' | '102' | '103' | '200' | '201' | '202' | '203' | '204' | '205' | '206' | '207' | '208' | '226' | '300' | '301' | '302' | '303' | '304' | '305' | '306' | '307' | '308' | '400' | '401' | '402' | '403' | '404' | '405' | '406' | '407' | '408' | '409' | '410' | '411' | '412' | '413' | '414' | '415' | '416' | '417' | '418' | '421' | '422' | '423' | '424' | '425' | '426' | '428' | '429' | '431' | '451' | '500' | '501' | '502' | '503' | '504' | '505' | '506' | '507' | '508' | '510' | '511';

package/dist/mjs/Swagger/Meta/SwaggerTypesStatic.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/ban-types */
+export {};

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

@@ -0,0 +1,28 @@
+import { CoreEntity } from '@grandlinex/core';
+import { HttpStatusTypes } from '../Meta/SwaggerTypesStatic.js';
+import { SKey, SSchemaEl, SwaggerContent, SwaggerRPathConfResponse, SwaggerRPathReqBody } from '../Meta/SwaggerTypes.js';
+export default class SPathUtil {
+    static defaultResponse(...types: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    static jsonBody(schema: SSchemaEl): SwaggerRPathReqBody;
+    static formBody(schema?: SSchemaEl): SwaggerRPathReqBody;
+    static entityContent<T extends CoreEntity>(entity: T, list?: boolean): SwaggerContent | undefined;
+    static entityResponse<T extends CoreEntity>(entity: T, list?: boolean, create?: boolean): SwaggerRPathConfResponse;
+    static schemaPath(inp: string): string;
+    static refResponse(code: HttpStatusTypes, $ref: string | CoreEntity, list: boolean, ...addCodes: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    static jsonResponse(code: HttpStatusTypes, schema: SSchemaEl, list: boolean, ...addCodes: HttpStatusTypes[]): SwaggerRPathConfResponse;
+    static schemaFromEntity<T extends CoreEntity>(entity: T): SSchemaEl | undefined;
+    static contentSchemaFromEntity<T extends CoreEntity>(entity: T): {
+        description: string;
+        content: {
+            'application/json': {
+                schema: SSchemaEl;
+            };
+        };
+    } | undefined;
+    /**
+     * generate global schema
+     * @param e
+     */
+    static schemaEntryGen(...e: CoreEntity[]): SKey<SSchemaEl>;
+    static schemaFromEntityView<A extends CoreEntity, B extends CoreEntity>(entity: A, entityMap: B): SSchemaEl;
+}

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

@@ -0,0 +1,222 @@
+import { getEntityMeta, XUtil, getColumnMeta, } from '@grandlinex/core';
+import map from './SUtilMap.js';
+function resolveDBType(dType) {
+    switch (dType) {
+        case 'int':
+            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 default class SPathUtil {
+    static defaultResponse(...types) {
+        const res = {};
+        types.forEach((el) => {
+            res[el] = map[el];
+        });
+        return res;
+    }
+    static jsonBody(schema) {
+        return {
+            content: {
+                'application/json': {
+                    schema,
+                },
+            },
+        };
+    }
+    static formBody(schema) {
+        return {
+            content: {
+                'multipart/form-data': {
+                    schema: schema || {
+                        type: 'object',
+                        properties: {
+                            file: {
+                                type: 'string',
+                                format: 'binary',
+                                description: 'File to upload',
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    static entityContent(entity, list) {
+        const schema = this.schemaFromEntity(entity);
+        if (!schema) {
+            return undefined;
+        }
+        if (list) {
+            return {
+                'application/json': {
+                    schema: {
+                        type: 'array',
+                        items: schema,
+                    },
+                },
+            };
+        }
+        return {
+            'application/json': {
+                schema,
+            },
+        };
+    }
+    static entityResponse(entity, list, create) {
+        const code = create ? '201' : '200';
+        const an = {};
+        an[code] = {
+            description: map[code].description,
+            content: this.entityContent(entity, list),
+        };
+        return an;
+    }
+    static schemaPath(inp) {
+        return `#/components/schemas/${inp}`;
+    }
+    static refResponse(code, $ref, list, ...addCodes) {
+        const an = {
+            ...this.defaultResponse(...addCodes),
+        };
+        const t = typeof $ref === 'string'
+            ? { $ref }
+            : {
+                $ref: this.schemaPath(XUtil.getEntityNames($ref).className),
+            };
+        if (list) {
+            an[code] = {
+                description: map[code].description,
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'array',
+                            items: t,
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            an[code] = {
+                description: map[code].description,
+                content: {
+                    'application/json': {
+                        schema: t,
+                    },
+                },
+            };
+        }
+        return an;
+    }
+    static jsonResponse(code, schema, list, ...addCodes) {
+        const an = {
+            ...this.defaultResponse(...addCodes),
+        };
+        if (list) {
+            an[code] = {
+                description: map[code].description,
+                content: {
+                    'application/json': {
+                        schema: {
+                            type: 'array',
+                            items: schema,
+                        },
+                    },
+                },
+            };
+        }
+        else {
+            an[code] = {
+                description: map[code].description,
+                content: {
+                    'application/json': {
+                        schema,
+                    },
+                },
+            };
+        }
+        return an;
+    }
+    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) {
+                if (!cMeta.canBeNull) {
+                    schema.required?.push(k);
+                }
+                schema.properties[k] = {
+                    type: resolveDBType(cMeta.dataType),
+                };
+            }
+        });
+        return schema;
+    }
+    static contentSchemaFromEntity(entity) {
+        const meta = getEntityMeta(entity);
+        if (!meta) {
+            return undefined;
+        }
+        return {
+            description: `Entity: ${meta.name}`,
+            content: {
+                'application/json': {
+                    schema: this.schemaFromEntity(entity),
+                },
+            },
+        };
+    }
+    /**
+     * generate global schema
+     * @param e
+     */
+    static schemaEntryGen(...e) {
+        const out = {};
+        e.forEach((el) => {
+            const meta = getEntityMeta(el);
+            if (meta) {
+                out[meta.name] = SPathUtil.schemaFromEntity(el);
+            }
+        });
+        return out;
+    }
+    static schemaFromEntityView(entity, entityMap) {
+        return {
+            type: 'object',
+            properties: {
+                i: {
+                    type: 'integer',
+                },
+                dat: this.schemaFromEntity(entity),
+                join_map: this.schemaFromEntity(entityMap),
+            },
+        };
+    }
+}

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

@@ -0,0 +1,192 @@
+declare const DefaultMap: {
+    '100': {
+        description: string;
+    };
+    '101': {
+        description: string;
+    };
+    '102': {
+        description: string;
+    };
+    '103': {
+        description: string;
+    };
+    '200': {
+        description: string;
+    };
+    '201': {
+        description: string;
+    };
+    '202': {
+        description: string;
+    };
+    '203': {
+        description: string;
+    };
+    '204': {
+        description: string;
+    };
+    '205': {
+        description: string;
+    };
+    '206': {
+        description: string;
+    };
+    '207': {
+        description: string;
+    };
+    '208': {
+        description: string;
+    };
+    '226': {
+        description: string;
+    };
+    '300': {
+        description: string;
+    };
+    '301': {
+        description: string;
+    };
+    '302': {
+        description: string;
+    };
+    '303': {
+        description: string;
+    };
+    '304': {
+        description: string;
+    };
+    '305': {
+        description: string;
+    };
+    '306': {
+        description: string;
+    };
+    '307': {
+        description: string;
+    };
+    '308': {
+        description: string;
+    };
+    '400': {
+        description: string;
+    };
+    '401': {
+        description: string;
+    };
+    '402': {
+        description: string;
+    };
+    '403': {
+        description: string;
+    };
+    '404': {
+        description: string;
+    };
+    '405': {
+        description: string;
+    };
+    '406': {
+        description: string;
+    };
+    '407': {
+        description: string;
+    };
+    '408': {
+        description: string;
+    };
+    '409': {
+        description: string;
+    };
+    '410': {
+        description: string;
+    };
+    '411': {
+        description: string;
+    };
+    '412': {
+        description: string;
+    };
+    '413': {
+        description: string;
+    };
+    '414': {
+        description: string;
+    };
+    '415': {
+        description: string;
+    };
+    '416': {
+        description: string;
+    };
+    '417': {
+        description: string;
+    };
+    '418': {
+        description: string;
+    };
+    '421': {
+        description: string;
+    };
+    '422': {
+        description: string;
+    };
+    '423': {
+        description: string;
+    };
+    '424': {
+        description: string;
+    };
+    '425': {
+        description: string;
+    };
+    '426': {
+        description: string;
+    };
+    '428': {
+        description: string;
+    };
+    '429': {
+        description: string;
+    };
+    '431': {
+        description: string;
+    };
+    '451': {
+        description: string;
+    };
+    '500': {
+        description: string;
+    };
+    '501': {
+        description: string;
+    };
+    '502': {
+        description: string;
+    };
+    '503': {
+        description: string;
+    };
+    '504': {
+        description: string;
+    };
+    '505': {
+        description: string;
+    };
+    '506': {
+        description: string;
+    };
+    '507': {
+        description: string;
+    };
+    '508': {
+        description: string;
+    };
+    '510': {
+        description: string;
+    };
+    '511': {
+        description: string;
+    };
+};
+export default DefaultMap;