@grandlinex/swagger-mate 0.30.8

package/dist/cjs/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;

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

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultMap = {
+    '100': {
+        description: 'Continue',
+    },
+    '101': {
+        description: 'Switching protocols',
+    },
+    '102': {
+        description: 'Processing',
+    },
+    '103': {
+        description: 'Early Hints',
+    },
+    '200': {
+        description: 'OK',
+    },
+    '201': {
+        description: 'Created',
+    },
+    '202': {
+        description: 'Accepted',
+    },
+    '203': {
+        description: '	Non-Authoritative Information',
+    },
+    '204': {
+        description: 'No Content',
+    },
+    '205': {
+        description: 'Reset Content',
+    },
+    '206': {
+        description: 'Partial Content',
+    },
+    '207': {
+        description: 'Multi-Status',
+    },
+    '208': {
+        description: 'Already Reported',
+    },
+    '226': {
+        description: 'IM Used',
+    },
+    '300': {
+        description: 'Multiple Choices',
+    },
+    '301': {
+        description: 'Moved Permanently',
+    },
+    '302': {
+        description: 'Found (Previously MovedTemporarily)',
+    },
+    '303': {
+        description: 'See Other',
+    },
+    '304': {
+        description: 'Not Modified',
+    },
+    '305': {
+        description: 'Use Proxy',
+    },
+    '306': {
+        description: 'Switch Proxy',
+    },
+    '307': {
+        description: 'Temporary Redirect',
+    },
+    '308': {
+        description: 'Permanent Redirect',
+    },
+    '400': {
+        description: 'Bad Request',
+    },
+    '401': {
+        description: 'Unauthorized',
+    },
+    '402': {
+        description: 'Payment Required',
+    },
+    '403': {
+        description: 'Forbidden',
+    },
+    '404': {
+        description: 'Not Found',
+    },
+    '405': {
+        description: 'Method Not Allowed',
+    },
+    '406': {
+        description: 'Not Acceptable',
+    },
+    '407': {
+        description: 'Proxy Authentication Required',
+    },
+    '408': {
+        description: 'Request Timeout',
+    },
+    '409': {
+        description: 'Conflict',
+    },
+    '410': {
+        description: 'Gone',
+    },
+    '411': {
+        description: 'Length Required',
+    },
+    '412': {
+        description: 'Precondition Failed',
+    },
+    '413': {
+        description: 'Payload Too Large',
+    },
+    '414': {
+        description: 'URI Too Long',
+    },
+    '415': {
+        description: 'Unsupported Media Type',
+    },
+    '416': {
+        description: 'Range Not Satisfiable',
+    },
+    '417': {
+        description: 'Expectation Failed',
+    },
+    '418': {
+        description: "I'm a Teapot",
+    },
+    '421': {
+        description: 'Misdirected Request',
+    },
+    '422': {
+        description: 'Unprocessable Entity',
+    },
+    '423': {
+        description: 'Locked',
+    },
+    '424': {
+        description: 'Failed Dependency',
+    },
+    '425': {
+        description: 'Too Early',
+    },
+    '426': {
+        description: 'Upgrade Required',
+    },
+    '428': {
+        description: 'Precondition Required',
+    },
+    '429': {
+        description: 'Too Many Requests',
+    },
+    '431': {
+        description: 'Request Header Fields Too Large',
+    },
+    '451': {
+        description: 'Unavailable For Legal Reasons',
+    },
+    '500': {
+        description: 'Internal Server Error',
+    },
+    '501': {
+        description: 'Not Implemented',
+    },
+    '502': {
+        description: 'Bad Gateway',
+    },
+    '503': {
+        description: 'Service Unavailable',
+    },
+    '504': {
+        description: 'Gateway Timeout',
+    },
+    '505': {
+        description: 'HTTP Version Not Supported',
+    },
+    '506': {
+        description: 'Variant Also Negotiates',
+    },
+    '507': {
+        description: 'Insufficient Storage',
+    },
+    '508': {
+        description: 'Loop Detected',
+    },
+    '510': {
+        description: 'Not Extended',
+    },
+    '511': {
+        description: 'Network Authentication Required',
+    },
+};
+exports.default = DefaultMap;

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { ObjectLike } from '@grandlinex/core';
+import { Server } from 'net';
+import { MergeInputType, SwaggerConfig } from './Meta/SwaggerTypes.js';
+export default class SwaggerUtil {
+    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>;
+    static metaExtractor(root: ObjectLike, npmPackageVersion: boolean, ...path: ObjectLike[]): SwaggerConfig | undefined;
+    static merge(root: SwaggerConfig, data: MergeInputType[]): SwaggerConfig;
+    static mergeConfig(root: SwaggerConfig, data: SwaggerConfig[]): SwaggerConfig;
+}

package/dist/cjs/Swagger/SwaggerUtil.js

@@ -0,0 +1,195 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 Path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const core_1 = require("@grandlinex/core");
+const express_1 = __importDefault(require("express"));
+const process = __importStar(require("process"));
+const Swagger_js_1 = require("./Meta/Swagger.js");
+const PathHelp_js_1 = __importStar(require("../PathHelp.js"));
+class SwaggerUtil {
+    static writeMeta(conf, kind, path) {
+        if (kind === 'JSON') {
+            const p = Path.join(path || process.cwd(), 'openapi.json');
+            fs.writeFileSync(p, JSON.stringify(conf, null, 2));
+        }
+        else {
+            const y = Path.join(path || process.cwd(), 'openapi.yml');
+            fs.writeFileSync(y, js_yaml_1.default.dump(conf));
+        }
+    }
+    static readMeta(path) {
+        const file = fs.readFileSync(path, 'utf-8');
+        try {
+            return JSON.parse(file);
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    static async serveMeta(conf, port, auth) {
+        const resFiles = (0, PathHelp_js_1.default)((0, PathHelp_js_1.getBaseFolder)(), '..', 'res', 'html');
+        const key = auth ? `?auth=${auth}` : '';
+        const app = (0, express_1.default)();
+        app.use('/', express_1.default.static(resFiles));
+        app.get('/spec', (req, res) => {
+            res.status(200).send(conf);
+        });
+        return new Promise((resolve) => {
+            const s = app.listen(port || 9000, () => {
+                console.log(`listen on http://localhost:${port || 9000}${key}#`);
+                resolve(s);
+            });
+        });
+    }
+    static metaExtractor(root, npmPackageVersion, ...path) {
+        const rootMeta = (0, Swagger_js_1.getSwaggerMeta)(root);
+        if (!rootMeta) {
+            return undefined;
+        }
+        if (npmPackageVersion) {
+            const version = process.env.npm_package_version;
+            if (version) {
+                rootMeta.info.version = version;
+            }
+        }
+        return this.merge(rootMeta, path.map((el) => ({
+            path: (0, Swagger_js_1.getSPath)(el),
+            comp: (0, Swagger_js_1.getSComponent)(el),
+        })));
+    }
+    static merge(root, data) {
+        const out = root;
+        if (!out.paths) {
+            out.paths = {};
+        }
+        if (!out.components) {
+            out.components = {};
+        }
+        data.forEach(({ path, comp }) => {
+            if (path && out.paths) {
+                const keys = Object.keys(path.path);
+                for (const key of keys) {
+                    if (key) {
+                        const nKey = `${path.prefix || ''}${key}`;
+                        const ac = path.path[key];
+                        if (ac) {
+                            const comps = Object.keys(ac);
+                            if (!out.paths[nKey]) {
+                                out.paths[nKey] = {};
+                            }
+                            if (out.paths[nKey]) {
+                                for (const c of comps) {
+                                    const nC = c;
+                                    out.paths[nKey][nC] = ac[nC];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (comp && out.components) {
+                const keys = Object.keys(comp);
+                for (const key of keys) {
+                    if (key) {
+                        const nKey = key;
+                        const ac = comp[nKey];
+                        if (ac) {
+                            const comps = Object.keys(ac);
+                            if (!out.components[nKey]) {
+                                out.components[nKey] = {};
+                            }
+                            if (out.components[nKey]) {
+                                for (const c of comps) {
+                                    out.components[nKey][c] = ac[c];
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        return out;
+    }
+    static mergeConfig(root, data) {
+        const out = root;
+        const path = new core_1.CMap();
+        const compSecurity = new core_1.CMap();
+        const compSchema = new core_1.CMap();
+        const compRespons = new core_1.CMap();
+        function fillKeys(obj, map) {
+            if (obj) {
+                const keys = Object.keys(obj);
+                for (const key of keys) {
+                    if (!map.has(key)) {
+                        map.set(key, obj[key]);
+                    }
+                }
+            }
+        }
+        if (!out.paths) {
+            out.paths = {};
+        }
+        if (!out.components) {
+            out.components = {};
+        }
+        [root, ...data].forEach((sc) => {
+            fillKeys(sc.paths, path);
+            fillKeys(sc.components?.securitySchemes, compSecurity);
+            fillKeys(sc.components?.schemas, compSchema);
+            fillKeys(sc.components?.responses, compRespons);
+        });
+        if (path.size > 0) {
+            path.forEach((x, key) => {
+                out.paths[key] = x;
+            });
+        }
+        if (compSecurity.size > 0) {
+            out.components.securitySchemes = {};
+            compSecurity.forEach((x, key) => {
+                out.components.securitySchemes[key] = x;
+            });
+        }
+        if (compSchema.size > 0) {
+            out.components.schemas = {};
+            compSchema.forEach((x, key) => {
+                out.components.schemas[key] = x;
+            });
+        }
+        if (compRespons.size > 0) {
+            out.components.responses = {};
+            compRespons.forEach((x, key) => {
+                out.components.responses[key] = x;
+            });
+        }
+        return out;
+    }
+}
+exports.default = SwaggerUtil;

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

@@ -0,0 +1,68 @@
+/**
+ * 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>>;
+}
+export default class BaseCon {
+    api: string;
+    permanentHeader: undefined | Record<string, string>;
+    authorization: string | null;
+    disconnected: boolean;
+    failFlag: boolean;
+    logger: (arg: any) => void;
+    con: ConHandle;
+    reconnect: () => Promise<boolean>;
+    onReconnect: (con: BaseCon) => Promise<boolean>;
+    constructor(conf: {
+        con: ConHandle;
+        endpoint: string;
+        logger?: (arg: any) => void;
+    });
+    isConnected(): boolean;
+    token(): string;
+    p(path: string, config?: ConHandleConfig): string;
+    ping(): Promise<boolean>;
+    test(email: string, password: string): Promise<boolean>;
+    testToken(): Promise<boolean>;
+    connect(email: string, pw: string): Promise<boolean>;
+    /**
+     * Enable client before auth
+     */
+    fakeEnableClient(): void;
+    handle<T, J>(type: 'POST' | 'GET' | 'PATCH' | 'DELETE', path: string, body?: J, config?: ConHandleConfig): Promise<HandleRes<T>>;
+}