@simitgroup/simpleapp-generator 1.6.7-i-alpha → 1.6.7-j-alpha

package/ReleaseNote.md

@@ -1,4 +1,10 @@
-[1.6.7h-alpha]
+[1.6.7j-alpha]
+
+1. Add Custom Field Constant File For Mini Api
+2. Update Scope Constant File
+3. Implement read/write split. for read data mongoose preferable go secondary server, which hope can reduce primary server load
+
+[1.6.7i-alpha]
 
 1. Restructure Mini App
 2. Support Mini Api Access

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simitgroup/simpleapp-generator",
-  "version": "1.6.7i-alpha",
+  "version": "1.6.7j-alpha",
   "description": "frontend nuxtjs and backend nests code generator using jsonschema",
   "main": "dist/index.js",
   "scripts": {

package/templates/basic/miniApi/resource.controller.ts.eta

@@ -4,8 +4,27 @@
   const apiName = it.typename.toUpperCase() + 'Api';
   const titleName = titleCase(pascalName);
   const uglyName = upperFirstCase(it.name ?? '');
+  const schemaName = `SimtrainSchema.${uglyName}`;
+  const schemaAutoCompleteName = `SimtrainSchema.${uglyName}AutoComplete`;
 
   const serviceVariable = it.resourceName + 'Service';
+
+  const getTypeName = (typeName) => {
+    const systemTypes = ['boolean', 'string', 'number', 'object', 'integer'];
+    let tmpTypeName = typeName.replace('[','').replace(']','');
+
+    if(systemTypes.includes(tmpTypeName.toLowerCase())){
+        tmpTypeName = upperFirstCase(tmpTypeName.toLowerCase());
+    } else {
+        tmpTypeName = `SimtrainSchema.${tmpTypeName}`;
+    }
+
+    if(typeName.includes('[')){
+        return `[${tmpTypeName}]`;
+    }
+
+    return tmpTypeName;
+  }
 %>
 
 import {
@@ -20,11 +39,12 @@ import {
   Headers,
   Query,
 } from '@nestjs/common';
-import { ApiTags, ApiBody, ApiResponse, ApiOperation, ApiQuery } from '@nestjs/swagger';
+import { ApiTags, ApiBody, ApiResponse, ApiOperation, ApiQuery, PartialType } from '@nestjs/swagger';
 import { ApiHeader } from 'src/types/api';
 import { <%= pascalName %>Service } from './<%= kebabName %>.service';
 import { ResourceApiListDto } from '../../dto/resource-api.schema';
-import { <%= uglyName %> } from 'src/openapi/backend-api';
+import * as SimtrainSchema from '../../simtrain-schema';
+import { Filter } from 'mongodb';
 
 @ApiTags('<%= titleName %>')
 @Controller('resources/<%= kebabName %>')
@@ -36,111 +56,154 @@ export class <%= pascalName %>Controller {
 
         <% if(action === 'list') { %>
             @Post('list')
-            @ApiBody({
-                type: ResourceApiListDto<<%= uglyName %>>,
-                required: false,
-            })
-            findAll(@Headers() headers:ApiHeader, @Body() dto?: ResourceApiListDto<<%= uglyName %>>) {
-                return this.<%= serviceVariable %>.findAll(headers, dto);
+            @ApiOperation({ operationId: 'list' })
+            @ApiBody({ type: ResourceApiListDto<<%= schemaName %>>, required: false })
+            @ApiResponse({ status: 200, description: 'Success', type: [<%= schemaName %>] })
+            @ApiResponse({ status: 400, description: 'Bad Request' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async findAll(@Headers() headers:ApiHeader, @Body() dto?: ResourceApiListDto<<%= schemaName %>>) {
+                return await this.<%= serviceVariable %>.findAll(headers, dto);
             }
         <% } else if(action === 'detail') { %>
             @Get(':id')
-            findOne(@Headers() headers: ApiHeader, @Param('id') id: string) {
-                return this.<%= serviceVariable %>.findOne(headers, id);
+            @ApiOperation({ operationId: 'detail' })
+            @ApiResponse({ status: 200, description: 'Success', type: <%= schemaName %> })
+            @ApiResponse({ status: 404, description: 'Not Found' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async findOne(@Headers() headers: ApiHeader, @Param('id') id: string) {
+                return await this.<%= serviceVariable %>.findOne(headers, id);
             }
         <% } else if(action === 'create') { %>
             @Post()
-            @ApiBody({})
-            create(
+            @ApiOperation({ operationId: 'create' })
+            @ApiBody({ type: <%= schemaName %>, required: true })
+            @ApiResponse({ status: 200, description: 'Success', type: <%= schemaName %> })
+            @ApiResponse({ status: 400, description: 'Bad Request' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async create(
                 @Headers() headers: ApiHeader,
                 @Body() resourceDto: any,
             ) {
-                return this.<%= serviceVariable %>.create(headers, resourceDto);
+                return await this.<%= serviceVariable %>.create(headers, resourceDto);
             }
         <% } else if(action === 'update') { %>
             @Put(':id')
-            @ApiBody({})
-            update(
+            @ApiOperation({ operationId: 'update' })
+            @ApiBody({ type: <%= schemaName %>, required: true })
+            @ApiResponse({ status: 200, description: 'Success', type: <%= schemaName %> })
+            @ApiResponse({ status: 400, description: 'Bad Request' })
+            @ApiResponse({ status: 404, description: 'Not Found' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async update(
                 @Headers() headers: ApiHeader,
                 @Param('id') id: string,
                 @Body() resourceDto: any,
             ) {
-                return this.<%= serviceVariable %>.update(headers, id, resourceDto);
+                return await this.<%= serviceVariable %>.update(headers, id, resourceDto);
             }
         <% } else if(action === 'patch') { %>
             @Patch(':id')
-            @ApiBody({})
-            patch(
+            @ApiOperation({ operationId: 'patch' })
+            @ApiBody({ type: PartialType(<%= schemaName %>), required: true })
+            @ApiResponse({ status: 200, description: 'Success', type: <%= schemaName %> })
+            @ApiResponse({ status: 400, description: 'Bad Request' })
+            @ApiResponse({ status: 404, description: 'Not Found' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async patch(
                 @Headers() headers: ApiHeader,
                 @Param('id') id: string,
                 @Body() resourceDto: any,
             ) {
-                return this.<%= serviceVariable %>.patch(headers, id, resourceDto);
+                return await  this.<%= serviceVariable %>.patch(headers, id, resourceDto);
             }
         <% } else if(action === 'delete') { %>
             @Delete(':id')
-            delete(
+            @ApiOperation({ operationId: 'delete' })
+            @ApiResponse({ status: 200, description: 'Success', type: <%= schemaName %> })
+            @ApiResponse({ status: 400, description: 'Bad Request' })
+            @ApiResponse({ status: 404, description: 'Not Found' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async delete(
                 @Headers() headers: ApiHeader,
                 @Param('id') id: string,
             ) {
-                return this.<%= serviceVariable %>.delete(headers, id);
+                return await this.<%= serviceVariable %>.delete(headers, id);
             }
         <% } else if(action === 'autoComplete') { %>
-            @Post('autocomplete')
+            @Post('autoComplete')
+            @ApiOperation({ operationId: 'autoComplete' })
             @ApiQuery({ name: 'query', type: String })
             @ApiBody({ description: 'Mongo DB Filter', type: () => Object })
-            findAutocomplete(
+            @ApiResponse({ status: 200, description: 'Success', type: <%= schemaAutoCompleteName %> })
+            @ApiResponse({ status: 400, description: 'Bad Request' })
+            @ApiResponse({ status: 404, description: 'Not Found' })
+            @ApiResponse({ status: 500, description: 'Internal Error' })
+            async findAutocomplete(
                 @Headers() headers: ApiHeader,
                 @Query('query') query: string,
-                @Body() filter: any,
+                @Body() filter: Filter<<%= schemaName %>>,
             ) {
-                return this.<%= serviceVariable %>.autocomplete(headers, query, filter);
+                return await this.<%= serviceVariable %>.autocomplete(headers, query, filter);
             }
         <% } else if(action === 'current') { %>
         <% } else { %>
-            <% const apiSetting = it.apiSettings.find(item => item.action === action); %>
-            <% if (apiSetting) { %>
-                <% const hasBody = ['post', 'put', 'patch'].includes(apiSetting.method); %>
+            <% const api = it.apiSettings.find(item => item.action === action); %>
+            <% if (api) { %>
+                <% const hasBody = ['post', 'put', 'patch'].includes(api.method); %>
 
-                <% 
-                    const paramMatches = apiSetting.entryPoint.match(/:([\w]+)/g) || [];
-                    const paramNames = paramMatches.map(p => p.replace(':', ''));
+                <%
+                    const paramsWithType = [];
+                    const paramsWithoutType = [];
 
-                    const args = [];
-                    const output = [];
-                    const queryParams = [];
+                    if(api.entryPoint && api.entryPoint.includes(':')) {
+                        let subpath = api.entryPoint.split('/');
+                        for(let a = 0; a < subpath.length; a++) {
+                        const partstr = subpath[a];
+                        if(partstr.includes(':')) {
+                            const paraname = partstr.replace(':','');
+                            paramsWithType.push(`${paraname}: string`);
+                            paramsWithoutType.push(paraname);
+                        }
+                        }
+                    }
 
-                    for (let i = 0; i < paramNames.length; i++) {
-                        const name = paramNames[i];
-                        args.push(name);
-                        output.push(name);
+                    if(api.queryPara && api.queryPara.length > 0) {
+                        for(let q=0; q < api.queryPara.length; q++) {
+                        const qp = api['queryPara'][q];
+                        paramsWithType.push(`${qp}: string`);
+                        paramsWithoutType.push(qp);
+                        }
                     }
 
-                    if (hasBody) {
-                        output.push('data');
+                    if(hasBody) {
+                        paramsWithType.push(`data: ${getTypeName(api.schema)}`);
+                        paramsWithoutType.push('data');
                     }
                 %>
 
-                @<%= upperFirstCase(apiSetting.method) %>('<%= apiSetting.entryPoint %>')
-                <% if (hasBody) { %>
-                    @ApiBody({ 
-                        description: 'Request Body',
-                    })
+                @<%= upperFirstCase(api.method) %>('<%= api.entryPoint %>')
+                @ApiOperation({ operationId: '<%= action %>', description: '<%= api.description %>' })
+                <% if(api.queryPara && api.queryPara.length > 0) { %>
+                    <% for(let q = 0; q < api.queryPara.length; q++) { %>
+                        @ApiQuery({name: "<%=api['queryPara'][q]%>", required: false, type: String})
+                    <% } %> 
                 <% } %>
-
-                <%= action %>(
+                <% if(hasBody) { %>
+                    @ApiBody({ type: <%= getTypeName(api.schema) %> })
+                <%}%>
+                @ApiResponse({ status: 200, description: 'Success', type: <%= getTypeName(api.responseType) %> })
+                @ApiResponse({ status: 400, description: 'Bad Request' })
+                @ApiResponse({ status: 500, description: 'Internal Error' })
+                async <%= action %>(
                     @Headers() headers: ApiHeader,
-                    <% args.forEach(arg => { %>
-                        @Param('<%= arg %>') <%= arg %>: string,
-                    <% }) %>
-                    <% if (hasBody) { %>
-                        @Body() data: any,
-                    <% } %>
-                ) {
-                    return this.<%= serviceVariable %>.<%= action %>(headers, <%= output.join(', ') %>);
+                    <%= paramsWithType.join(',') %>
+                ){
+                    return await this.<%= serviceVariable %>.<%= action %>(
+                        headers,
+                        <%= paramsWithoutType.join(', ') %>
+                    );
                 }
             <% } %>
         <% } %>
-        
     <% }); %>
 }

package/templates/basic/miniApi/resource.service.ts.eta

@@ -2,6 +2,25 @@
   const pascalName = upperFirstCase(it.resourceName);
   const apiName = it.typename.toUpperCase() + 'Api';
   const uglyName = upperFirstCase(it.name ?? '');
+  const schemaName = `SimtrainSchema.${uglyName}`;
+  const schemaAutoCompleteName = `SimtrainSchema.${uglyName}AutoComplete`;
+
+  const getTypeName = (typeName) => {
+    const systemTypes = ['boolean', 'string', 'number', 'object', 'integer'];
+    let tmpTypeName = typeName.replace('[','').replace(']','');
+
+    if(systemTypes.includes(tmpTypeName.toLowerCase())){
+        tmpTypeName = upperFirstCase(tmpTypeName.toLowerCase());
+    } else {
+        tmpTypeName = `SimtrainSchema.${tmpTypeName}`;
+    }
+
+    if(typeName.includes('[')){
+        return `[${tmpTypeName}]`;
+    }
+
+    return tmpTypeName;
+  }
 %>
 
 import { BadRequestException, Injectable } from '@nestjs/common';
@@ -10,7 +29,7 @@ import { <%= apiName %> } from 'src/openapi/backend-api';
 import { ApiHeader } from 'src/types/api';
 import { getOpenApiConfig } from 'src/utils/api';
 import { ResourceApiListDto } from '../../dto/resource-api.schema';
-import { <%= uglyName %> } from 'src/openapi/backend-api';
+import * as SimtrainSchema from '../../simtrain-schema';
 
 @Injectable()
 export class <%= pascalName %>Service {
@@ -30,7 +49,7 @@ export class <%= pascalName %>Service {
     <% if (value !== true && typeof value !== 'object') { return; } %>
     
     <% if(action === 'list') { %>
-      async findAll(headers: ApiHeader, dto?: ResourceApiListDto<<%= uglyName %>>) {
+      async findAll(headers: ApiHeader, dto?: ResourceApiListDto<<%= schemaName %>>) {
         const api = this.getApi(headers);
         const resp = await api.runSearch({
           fields: dto?.fields,
@@ -77,38 +96,48 @@ export class <%= pascalName %>Service {
       }
     <% } else if(action === 'current') { %>
     <% } else { %>
-      <% const apiSetting = it.apiSettings.find(item => item.action === action); %>
-      <% if (apiSetting) { %>
-        <% const hasBody = ['post', 'put', 'patch'].includes(apiSetting.method); %>
+      <% const api = it.apiSettings.find(item => item.action === action); %>
+      <% if (api) { %>
+        <% const hasBody = ['post', 'put', 'patch'].includes(api.method); %>
 
-        <% 
-          const paramMatches = apiSetting.entryPoint.match(/:([\w]+)/g) || [];
-          const paramNames = paramMatches.map(p => p.replace(':', ''));
+        <%
+          const paramsWithType = [];
+          const paramsWithoutType = [];
 
-          const args = paramNames.map(name => {
-            return `${name}: string`;
-          });
-
-          const output = [];
-          const queryParams = [];
-
-          for (let i = 0; i < paramNames.length; i++) {
-            const name = paramNames[i];
+          if(api.entryPoint && api.entryPoint.includes(':')) {
+            let subpath = api.entryPoint.split('/');
+            for(let a = 0; a < subpath.length; a++) {
+              const partstr = subpath[a];
+              if(partstr.includes(':')) {
+                const paraname = partstr.replace(':','');
+                paramsWithType.push(`${paraname}: string`);
+                paramsWithoutType.push(paraname);
+              }
+            }
+          }
 
-            output.push(name);
+          if(api.queryPara && api.queryPara.length > 0) {
+            for(let q=0; q < api.queryPara.length; q++) {
+              const qp = api['queryPara'][q];
+              paramsWithType.push(`${qp}: string`);
+              paramsWithoutType.push(qp);
+            }
           }
 
-          if (hasBody) {
-            args.push('data: any');
-            output.push('data');
+          if(hasBody) {
+            paramsWithType.push(`data: ${getTypeName(api.schema)}`);
+            paramsWithoutType.push('data');
           }
         %>
-        
-        async <%= action %>(headers: ApiHeader, <%= args.join(', ') %>) {
+
+        async <%= action %>(
+          headers: ApiHeader,
+          <%= paramsWithType.join(',') %>
+        ){
           const api = this.getApi(headers);
-          const resp = await api.run<%= upperFirstCase(action) %>(<%= output.join(', ') %>);
+          const resp = await api.run<%= upperFirstCase(action) %>(<%= paramsWithoutType.join(', ') %>);
           return resp.data;
-        }
+        } 
       <% } %>
     <% } %>
   <% }) %>

package/templates/miniApi/src/constants/api-scopes.ts.eta

@@ -7,45 +7,63 @@
     const resourcePascalName = upperFirstCase(simpleAppConfig.resourceName);
     const resourceKebabName = camelToKebab(simpleAppConfig.resourceName);
     const additionalApis = simpleAppConfig?.additionalApis || [];
+    const resourceTitleName = titleCase(resourcePascalName);
     let availableApis = {};
 
     Object.entries(miniAppWhitelistApis).forEach(([action, value]) => {
       if (value !== true && typeof value !== 'object') { return; }
       let method = '';
+      let description = '';
+
       switch(action) {
         case 'detail':
           method = 'get';
+          description = `Retrieve a single ${resourceTitleName} record by ID.`;
           break;
 
         case 'list':
+          method = 'post';
+          description = `Retrieve ${resourceTitleName} records with optional filtering, sorting, and field selection.`;
+          break;
+
         case 'create':
+          method = 'post';
+          description = `Create a new ${resourceTitleName} record.`;
+          break;
+
         case 'autoComplete':
           method = 'post';
+          description = `Retrieve a selectable list of ${resourceTitleName} options for dropdowns or autocomplete fields.`;
           break;
 
         case 'update':
           method = 'put';
+          description = `Replace an existing ${resourceTitleName} record with new data.`;
           break;
 
         case 'patch':
           method = 'patch';
+          description = `Update specific fields of an existing ${resourceTitleName} record.`;
           break;
 
         case 'delete':
           method = 'delete';
+          description = `Delete an existing ${resourceTitleName} record.`;
           break;
 
         case 'current':
           return;
-          break;
 
         default:
-          method = (additionalApis ?? []).find(item => item.action === action)?.method ?? '';
+          const additionalApiConfig = (additionalApis ?? []).find(item => item.action === action);
+          method = additionalApiConfig?.method ?? '';
+          description = additionalApiConfig?.description ?? '';
           break;
       }
 
       availableApis[action] = {
-        method: method
+        method: method,
+        description: description,
       }
     });
     

package/templates/miniApi/src/constants/available-custom-field.ts.eta

@@ -0,0 +1,22 @@
+<%
+  const modules = it.modules.sort((a, b) => a.docname.localeCompare(b.docname, undefined, { sensitivity: 'base' }));
+%>
+
+const customFields = [
+  <% modules.forEach(module => { %>
+    <%
+      const schema = module.schema; 
+      const simpleAppConfig = schema['x-simpleapp-config'];
+      const isEnabled = simpleAppConfig?.customField?.isEnable || false;
+    %>
+    <% if(isEnabled) { %>
+      {
+        documentType: '<%= simpleAppConfig.documentType%>',
+        documentName: '<%= simpleAppConfig.documentName%>',
+        resourceName: '<%= simpleAppConfig.resourceName%>',
+      },
+    <% } %>
+  <% }); %>
+];
+
+export default customFields;