ng2-rest-swagger-generator 21.0.17 → 21.0.19

package/lib-prod/helpers.js

@@ -0,0 +1,500 @@
+import { path, fse, ___NS__camelCase, ___NS__forOwn, ___NS__get, ___NS__isArray, ___NS__isUndefined, ___NS__upperFirst } from 'tnp-core/lib-prod';
+import { Helpers__NS__remove } from 'tnp-core/lib-prod';
+export class HelpersSwagger {
+    static {
+        this.SYMBOL = {
+            INDEX_SWG: Symbol(),
+            OUTPUT_FOLDER: Symbol(),
+        };
+    }
+    static preparePaths(apis, outputBase) {
+        this.output = `${process.cwd()}/${outputBase}`;
+        this.apis = apis;
+    }
+    static prepareModel(swg, indexSwg, isHttpsEnable) {
+        swg[this.SYMBOL.INDEX_SWG] = indexSwg;
+        swg.host =
+            swg.host &&
+                (isHttpsEnable ? 'https' : 'http') +
+                    `://${swg.host.replace(/:[0-9]*/g, '')}`;
+        if (!swg.basePath) {
+            swg.basePath = '';
+        }
+    }
+    //#region @backend
+    static recreateIfNotExist(pathToFileOrFolder, content) {
+        if (___NS__isUndefined(content)) {
+            if (fse.existsSync(pathToFileOrFolder)) {
+                Helpers__NS__remove(pathToFileOrFolder);
+            }
+            fse.mkdirpSync(pathToFileOrFolder);
+        }
+        else {
+            if (fse.existsSync(pathToFileOrFolder)) {
+                fse.unlinkSync(pathToFileOrFolder);
+            }
+            const dirName = path.dirname(pathToFileOrFolder);
+            if (!fse.existsSync(dirName)) {
+                fse.mkdirpSync(dirName);
+            }
+            fse.writeFileSync(pathToFileOrFolder, content, {
+                encoding: 'utf8',
+            });
+        }
+    }
+    //#endregion
+    static get serviceFromTag() {
+        const self = this;
+        return {
+            allClassNames() {
+                const names = [];
+                self.apis.map(swg => {
+                    swg.tags.forEach(tag => {
+                        // @ts-ignore
+                        names.push(self.serviceFromTag.className(swg, tag));
+                    });
+                });
+                return names;
+            },
+            className(swg, tag) {
+                const groupFolderName = self.groupFromJSON.folderName(swg);
+                // console.log('groupFolderName', groupFolderName)
+                const className = ___NS__upperFirst(___NS__camelCase(tag.name)) + 'Service';
+                return `${groupFolderName}${className.replace(/\//g, '')}`;
+            },
+            absoluteFilePath(swg, tag) {
+                return `${self.absolutePath.PathFolder_services_groupName(swg)}/${self.serviceFromTag.className(swg, tag)}.ts`;
+            },
+        };
+    }
+    static get endpoints() {
+        return this.apis.map(swg => {
+            return `${this.groupFromJSON.folderName(swg)}:'${swg.host}'`;
+        });
+    }
+    static get absolutePath() {
+        const self = this;
+        return {
+            get output() {
+                return self.output;
+            },
+            get PathFile_index_ts() {
+                const APIpath = self.output;
+                return `${APIpath}/index.ts`;
+            },
+            get PathFile_module_ts() {
+                const APIpath = self.output;
+                return `${APIpath}/module.ts`;
+            },
+            get PathFolder_services() {
+                const APIpath = self.output;
+                return `${APIpath}/services`;
+            },
+            get PathFile_services_index_ts() {
+                return `${self.absolutePath.PathFolder_services}/index.ts`;
+            },
+            PathFolder_services_groupName(swg) {
+                const groupFolderName = self.groupFromJSON.folderName(swg);
+                // console.log('groupFolderName', groupFolderName)
+                return `${self.absolutePath.PathFolder_services}/${groupFolderName}`;
+            },
+            PathFile_services_groupName_index_ts(swg) {
+                return `${self.absolutePath.PathFolder_services_groupName(swg)}/index.ts`;
+            },
+            PathFile_services_groupNAme_serviceName_ts(swg, tag) {
+                const serviceFileName = self.serviceFromTag.className(swg, tag);
+                return `${self.absolutePath.PathFolder_services_groupName(swg)}/${serviceFileName}.ts`;
+            },
+        };
+    }
+    static get groupFromJSON() {
+        const self = this;
+        return {
+            get allGroupNames() {
+                const names = [];
+                self.apis.map(swg => {
+                    // @ts-ignore
+                    names.push(self.groupFromJSON.folderName(swg));
+                });
+                return names;
+            },
+            folderName(swg) {
+                const basePath = swg.basePath;
+                const index = swg[self.SYMBOL.INDEX_SWG];
+                return ___NS__upperFirst(___NS__camelCase(basePath.trim() === '' ? `json${index}` : basePath));
+            },
+        };
+    }
+    static findTags(swg) {
+        const tags = [];
+        Object.keys(swg.paths).forEach(p => {
+            Object.keys(swg.paths[p]).forEach(m => {
+                const a = swg.paths[p][m];
+                if (___NS__isArray(a.tags)) {
+                    a.tags.forEach(tag => {
+                        if (tags.filter(({ name }) => name === tag).length === 0) {
+                            // @ts-ignore
+                            tags.push({ name: tag });
+                        }
+                    });
+                }
+            });
+        });
+        return tags;
+    }
+    /**
+     * To generate get/books/{id} => get_books__id_
+     */
+    static cleanPath(path) {
+        return path
+            .replace(/{/g, '_')
+            .replace(/}/g, '_')
+            .replace(/\//g, '_')
+            .replace(/-/g, '_');
+    }
+    static cleanPathModel(pathModel) {
+        return pathModel.replace(/\/{/g, '/:').replace(/}/g, '');
+    }
+    static swaggerTypeToJS(type, itemsType = 'any') {
+        return type === 'integer'
+            ? 'number'
+            : type === 'array'
+                ? !itemsType
+                    ? 'any'
+                    : `${this.swaggerTypeToJS(itemsType)}[]`
+                : type === 'file'
+                    ? 'any'
+                    : type;
+    }
+    static getObjectDefinition(ref, swg, deep = 0) {
+        if (deep == 1)
+            return '';
+        if (!ref) {
+            console.log('Bad json $ref inside swagger');
+            return '';
+        }
+        let res = '';
+        ref = ref.replace('#/', '').replace(/\//g, '.');
+        let obj = (___NS__get(swg, ref));
+        // if (obj.properties.viaAgentViaGroupDTOs && !getObjectDefinition.prototype.once) {
+        //     console.log('============================================================')
+        //     console.log('obj', obj)
+        //     console.log('------------------------------------------------------------')
+        //     getObjectDefinition.prototype.once = true;
+        ___NS__forOwn(obj.properties, (v, k) => {
+            // console.log(obj)
+            if (v.$ref && typeof v.$ref === 'string') {
+                res +=
+                    k + ':{' + this.getObjectDefinition(v.$ref, swg, deep++) + '};\n';
+            }
+            else if (v.schema &&
+                v.schema.$ref &&
+                typeof v.schema.$ref === 'string') {
+                res +=
+                    k +
+                        ':{' +
+                        this.getObjectDefinition(v.schema.$ref, swg, deep++) +
+                        '};\n';
+            }
+            else if (v.items &&
+                v.items.$ref &&
+                typeof v.items.$ref === 'string' &&
+                v.type &&
+                v.type === 'array') {
+                res +=
+                    k +
+                        ':{' +
+                        this.getObjectDefinition(v.items.$ref, swg, deep++) +
+                        '}[];\n';
+                // console.log('make love here')
+            }
+            else if (v.items && v.items.$ref && typeof v.items.$ref === 'string') {
+                res +=
+                    k +
+                        ':{' +
+                        this.getObjectDefinition(v.items.$ref, swg, deep++) +
+                        '};\n';
+            }
+            else {
+                let isRequired = obj.required &&
+                    obj.required instanceof Array &&
+                    obj.required.filter(o => o === k).length > 0;
+                let type = v.enum && v.enum instanceof Array && v.enum.length > 0
+                    ? v.enum.map(e => '"' + e + '"').join('|')
+                    : this.swaggerTypeToJS(v.type, v.items ? v.items.type : 'any');
+                res += k + (!isRequired ? '?' : '') + ':' + type + ';\n';
+            }
+        });
+        //     console.log('res', res)
+        // }
+        return res;
+    }
+    /**
+     * private pathes = {
+     *      get_all_companies: new SimpleResource<
+     *          string, A, TA, RP extends Object, QP extends Rest.UrlParams>(endpoint, model),
+     *      get_byid_companies: new SimpleResource<
+     *          string, A, TA, RP extends Object, QP extends Rest.UrlParams>(endpoint, model)
+     * }
+     */
+    static getAngularPrivatePathesByTag(swg, tag) {
+        let res = [];
+        let base = swg.basePath.replace('/', '');
+        let pathes = {};
+        ___NS__forOwn(swg.paths, (v, k) => {
+            ___NS__forOwn(v, (v2, k2) => {
+                if (___NS__isArray(v2.tags) &&
+                    v2.tags.filter(f => f === tag.name).length > 0) {
+                    let resp = v2.responses['200'] && v2.responses['200'].schema;
+                    // if (resp) {
+                    // TODO response handling
+                    // console.log('resp',resp);
+                    if (pathes[k] === void 0)
+                        pathes[k] = {}; // @ts-ignore
+                    let type = this.getResponseType(resp, swg);
+                    if (type.length > 3 &&
+                        type.charAt(type.length - 1) === ']' &&
+                        type.charAt(type.length - 2) === '[' &&
+                        !pathes[k]['array']) {
+                        pathes[k]['array'] = type;
+                    }
+                    else if (k2 !== 'delete' && !pathes[k]['single']) {
+                        pathes[k]['single'] = type;
+                    }
+                    // }
+                }
+            });
+        });
+        let pathResources = [];
+        ___NS__forOwn(pathes, (v, p) => {
+            // console.log(`${p} - ${JSON.stringify(v)}`);
+            pathResources.push({
+                clean_path: this.cleanPath(p),
+                model: this.cleanPathModel(p),
+                endpoint: swg.basePath,
+                singleModelType: !v['single'] ? 'any' : v['single'],
+                multipleModelType: !v['array'] ? 'any' : v['array'],
+                queryParamsType: 'any',
+                pathParamsType: 'any',
+            });
+        });
+        pathResources.forEach(p => {
+            res.push(`${p.clean_path}: new SimpleResource<\n${p.singleModelType},\n${p.multipleModelType}\n>( Ng2RestGenModule.enpointUrls.${this.groupFromJSON.folderName(swg)}, '${p.model}' )`);
+        });
+        return `private pathes = { \n${res.join(',\n')}\n};`;
+    }
+    /*
+     schema": {
+        "type": "array",
+        "items": {
+            "$ref": "#/definitions/CompanyDTO"
+        }
+    }
+  
+    "schema": {
+        "$ref": "#/definitions/CompanyDTO"
+    }
+     */
+    static getResponseType(o, swg) {
+        let res = '{} | any';
+        if (o && o.$ref && typeof o.$ref === 'string' && o.$ref.trim() !== '') {
+            res = '{' + this.getObjectDefinition(o.$ref, swg) + '}';
+            // console.log('I am object', o.$ref)
+        }
+        else if (o &&
+            o.type === 'array' &&
+            o.items &&
+            o.items.$ref &&
+            typeof o.items.$ref === 'string' &&
+            o.items.$ref.trim() !== '') {
+            res = '{' + this.getObjectDefinition(o.items.$ref, swg) + '}[]';
+            // console.log('I am array ', o.items.$ref)
+        }
+        // console.log('============================================================')
+        // console.log('type', res)
+        // console.log('------------------------------------------------------------')
+        return res;
+    }
+    //#region @backend
+    /**
+     * public getAllCompanies =  ({ params },{ queryparams1 }) => this.pathes.get_all_companies.model(params).get(queryparams),
+     * public getAllCompanies =  ({ params },{ queryparams1 },{body}) => this.pathes.get_all_companies.model(params).put(body,queryparams)
+     */
+    static getServicesMethod(swg, tag) {
+        let methods = [];
+        for (let urlpath in swg.paths) {
+            for (let methodhttp in swg.paths[urlpath]) {
+                let m = swg.paths[urlpath][methodhttp];
+                if (___NS__isArray(m.tags) &&
+                    m.tags.filter(t => t === tag.name).length === 1) {
+                    let sm = {};
+                    sm.summary = ___NS__camelCase(m.operationId ? m.operationId : m.summary);
+                    sm.method = methodhttp; // <Models.Morphi.Rest.HttpMethod>methodhttp;
+                    sm.path_cleand = this.cleanPath(urlpath);
+                    // console.log('sm.path_cleand', sm.path_cleand)
+                    sm.params = {};
+                    sm.params.query = [];
+                    sm.params.path = [];
+                    sm.params.body = [];
+                    sm.comment = '';
+                    // QUICKFIX
+                    if (m.responses &&
+                        m.responses['200'] &&
+                        m.responses['200'].schema && // @ts-ignore
+                        m.responses['200'].schema.type && // @ts-ignore
+                        m.responses['200'].schema.type === 'array') {
+                        sm.isArray = true;
+                    }
+                    if (m.parameters)
+                        m.parameters.forEach(param => {
+                            let ptypeExitst = param.type && param.type.length > 0;
+                            sm.comment +=
+                                '*' +
+                                    (ptypeExitst ? ` { ${param.type} } ` : ' ') +
+                                    `${param.name} (${param.description})` +
+                                    '\n';
+                            if (param.in === 'body') {
+                                let type;
+                                if (param.schema.items &&
+                                    param.schema.items.$ref &&
+                                    param.schema.type == 'array') {
+                                    type =
+                                        '{' +
+                                            this.getObjectDefinition(param.schema.items.$ref, swg) +
+                                            '}[]';
+                                }
+                                else {
+                                    type = param.schema.$ref
+                                        ? '{' +
+                                            this.getObjectDefinition(param.schema.$ref, swg) +
+                                            '}'
+                                        : this.swaggerTypeToJS(param.type);
+                                }
+                                // @ts-ignore
+                                sm.params.body.push({
+                                    name: param.name,
+                                    type,
+                                    required: param.required,
+                                    isObject: true,
+                                });
+                            }
+                            else {
+                                if (!___NS__isArray(sm.params[param.in])) {
+                                    sm.params[param.in] = [];
+                                }
+                                sm.params[param.in].push({
+                                    name: param.name,
+                                    type: this.swaggerTypeToJS(param.type),
+                                    required: param.required,
+                                });
+                            }
+                        });
+                    methods.push(sm);
+                }
+            }
+        }
+        return methods;
+    }
+    //#endregion
+    //#region @backend
+    static getAngularServicesMethods(swg, tag) {
+        let res = '';
+        let methods = this.getServicesMethod(swg, tag);
+        methods.forEach(m => {
+            let neededParams = {
+                path: m.params && m.params.path && m.params.path.length > 0,
+                query: m.params && m.params.query && m.params.query.length > 0,
+                body: m.params && m.params.body && m.params.body.length > 0,
+            };
+            let paramsPath = neededParams.path // @ts-ignore
+                ? m.params.path
+                    .map(p => (p['joined'] = p.name + ':' + p.type))
+                    .join(',')
+                : '';
+            let paramsQuery = neededParams.query // @ts-ignore
+                ? m.params.query
+                    .map(p => (p['joined'] = p.name + ':' + p.type))
+                    .join(',')
+                : '';
+            let paramsBody = neededParams.body // @ts-ignore
+                ? m.params.body
+                    .map(p => (p['joined'] = p.name + ':' + p.type))
+                    .join(',')
+                : '';
+            let paramPathNames = '{' +
+                (neededParams.path // @ts-ignore
+                    ? m.params.path
+                        .map(p => (p['joined'] = p.name))
+                        .filter(d => d)
+                        .join(',')
+                    : '') +
+                '}';
+            let paramQueryNames = '{' +
+                (neededParams.query // @ts-ignore
+                    ? m.params.query
+                        .map(p => (p['joined'] = p.name))
+                        .filter(d => d)
+                        .join(',')
+                    : '') +
+                '}';
+            let paramBodyNames = '{' +
+                (neededParams.body // @ts-ignore
+                    ? m.params.body
+                        .map(p => (p['joined'] = p.name))
+                        .filter(d => d)
+                        .join(',')
+                    : '') +
+                '}';
+            let method = m.method;
+            if (m.isArray && m.method === 'get')
+                method = 'query';
+            let params = [paramsPath, paramsQuery, paramsBody]
+                .filter(d => d && d !== '{}')
+                .join(',');
+            // QUICKFIX change {object} to object in method
+            // @ts-ignore
+            if (neededParams.query &&
+                m.params.query.length === 1 &&
+                m.params.query[0].isObject) {
+                // @ts-ignore
+                paramQueryNames = paramQueryNames.match(new RegExp('[a-zA-Z]+', 'g'))[0];
+            }
+            // @ts-ignore
+            if (neededParams.body &&
+                m.params.body.length === 1 &&
+                m.params.body[0].isObject) {
+                // @ts-ignore
+                paramBodyNames = paramBodyNames.match(new RegExp('[a-zA-Z]+', 'g'))[0];
+            }
+            let paramsName = [paramBodyNames, paramQueryNames]
+                .filter(d => d && d !== '{}')
+                .map(d => '<any>' + d)
+                .join(',');
+            let comment = m.comment
+                ? `/**` +
+                    '\n' +
+                    `${m.comment.trim()}
+        */`
+                : '';
+            res +=
+                `${comment}
+public` +
+                    this.recreateSummary(m.summary) +
+                    '= (' +
+                    params +
+                    ') =>\nthis.pathes.' +
+                    m.path_cleand +
+                    `\n.model(${paramPathNames}) \n.${method} (${paramsName}); ` +
+                    '\n';
+        });
+        return res;
+    }
+    //#endregion
+    static { this.count1 = 0; }
+    static recreateSummary(summary) {
+        // if (!summary) {
+        //   return 'SummaryExample' + (count1++)
+        // }
+        return summary;
+    }
+}

package/lib-prod/{index._auto-generated_.ts → index._auto-generated_.js}

@@ -2,4 +2,4 @@
 // This file is auto-generated during init process. Do not modify.
 // This is only placeholder.
 // Use property "shouldGenerateAutogenIndexFile: true" 
-// in taon.jsonc to enable ts exports auto generation. 
+// in taon.jsonc to enable ts exports auto generation.

package/lib-prod/migrations/index.js

@@ -0,0 +1,2 @@
+//@ts-nocheck
+export * from './migrations_index._auto-generated_';

package/lib-prod/migrations/{migrations_index._auto-generated_.ts → migrations_index._auto-generated_.js}

@@ -1,5 +1,3 @@
 // THIS FILE IS GENERATED - DO NOT MODIFY
-
 // THIS FILE IS GENERATED - DO NOT MODIFY
-
 // THIS FILE IS GENERATED - DO NOT MODIFY

package/lib-prod/models.js

@@ -0,0 +1,3 @@
+export {};
+//end of namespace Models__NS__Swagger
+//end of namespace Models

package/lib-prod/package.json

@@ -1,4 +1,4 @@
 {
   "name": "ng2-rest-swagger-generator/lib-prod",
-  "version": "21.0.17"
+  "version": "21.0.19"
 }

package/lib-prod.split-namespaces.json

@@ -1,42 +1,4 @@
 {
-  "namespacesMapObj": {
-    "Models.PathResource": "Models__NS__PathResource",
-    "Models.Param": "Models__NS__Param",
-    "Models.ServiceMethod": "Models__NS__ServiceMethod",
-    "Models.Swagger.DataFormat": "Models__NS__Swagger__NS__DataFormat",
-    "Models.Swagger.DataType": "Models__NS__Swagger__NS__DataType",
-    "Models.Swagger.PropertyName": "Models__NS__Swagger__NS__PropertyName",
-    "Models.Swagger.SwaggerDef": "Models__NS__Swagger__NS__SwaggerDef",
-    "Models.Swagger.SwaggerDefinition": "Models__NS__Swagger__NS__SwaggerDefinition",
-    "Models.Swagger.ObjSchema": "Models__NS__Swagger__NS__ObjSchema",
-    "Models.Swagger.Response": "Models__NS__Swagger__NS__Response",
-    "Models.Swagger.SwaggerResponse": "Models__NS__Swagger__NS__SwaggerResponse",
-    "Models.Swagger.Parameter": "Models__NS__Swagger__NS__Parameter",
-    "Models.Swagger.Method": "Models__NS__Swagger__NS__Method",
-    "Models.Swagger.SwaggerMethod": "Models__NS__Swagger__NS__SwaggerMethod",
-    "Models.Swagger.SwaggerPath": "Models__NS__Swagger__NS__SwaggerPath",
-    "Models.Swagger.SwaggerTag": "Models__NS__Swagger__NS__SwaggerTag",
-    "Models.Swagger.SwaggerModel": "Models__NS__Swagger__NS__SwaggerModel"
-  },
-  "namespacesReplace": {
-    "Models": [
-      "Models__NS__Param",
-      "Models__NS__PathResource",
-      "Models__NS__ServiceMethod",
-      "Models__NS__Swagger__NS__DataFormat",
-      "Models__NS__Swagger__NS__DataType",
-      "Models__NS__Swagger__NS__Method",
-      "Models__NS__Swagger__NS__ObjSchema",
-      "Models__NS__Swagger__NS__Parameter",
-      "Models__NS__Swagger__NS__PropertyName",
-      "Models__NS__Swagger__NS__Response",
-      "Models__NS__Swagger__NS__SwaggerDef",
-      "Models__NS__Swagger__NS__SwaggerDefinition",
-      "Models__NS__Swagger__NS__SwaggerMethod",
-      "Models__NS__Swagger__NS__SwaggerModel",
-      "Models__NS__Swagger__NS__SwaggerPath",
-      "Models__NS__Swagger__NS__SwaggerResponse",
-      "Models__NS__Swagger__NS__SwaggerTag"
-    ]
-  }
+  "namespacesMapObj": {},
+  "namespacesReplace": {}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng2-rest-swagger-generator",
-  "version": "21.0.17",
+  "version": "21.0.19",
   "scripts": {
     "test": "mocha --require ts-node/register src/**/*.spec.ts",
     "test:watch": "mocha --compilers ts-node/register src/**/*.spec.ts --watch",

package/websql/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng2-rest-swagger-generator/websql",
-  "version": "21.0.17",
+  "version": "21.0.19",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0"