@simitgroup/simpleapp-generator 1.6.7-e-alpha → 1.6.7-g-alpha

package/src/generate.ts

@@ -45,6 +45,7 @@ const docs = [];
 let frontendFolder = '';
 let backendFolder = '';
 let miniAppSdkFolder = {};
+let miniApiFolder = '';
 let frontendpagefolder = '';
 const allroles: any = {};
 let langdata: any = {};
@@ -61,6 +62,7 @@ export const run = async (
   frontendFolder = configs.frontendFolder;
   backendFolder = configs.backendFolder;
   miniAppSdkFolder = configs.miniAppSdkFolder;
+  miniApiFolder = configs.miniApiFolder;
 
   const printformats: SchemaPrintFormat[] = [];
   const groupFolder = configs.groupFolder;
@@ -78,6 +80,9 @@ export const run = async (
   if (genFor.includes('miniAppStreamlitSdk')) {
     generateTypes['miniAppStreamlitSdk'] = miniAppSdkFolder['streamlit'];
   }
+  if (genFor.includes('miniApi')) {
+    generateTypes['miniApi'] = miniApiFolder;
+  }
   // console.log("genForgenForgenForgenFor",genFor,generateTypes)
   //
   frontendpagefolder = `${frontendFolder}/pages/[xorg]`;
@@ -207,6 +212,9 @@ const generateSchema = (
     jsonschemas[docname]?.['x-simpleapp-config']?.resourceName ?? docname;
 
   //console.log("---^^^^^------",modelname,docname, doctype, rendertype,currentmodel,allmodels)
+
+  const miniAppWhitelistApis =
+    jsonschemas[docname][X_SIMPLEAPP_CONFIG]?.miniApp?.whitelist || {};
   const variables: TypeGenerateDocumentVariable = {
     resourceName: resourceName,
     name: docname,
@@ -234,6 +242,10 @@ const generateSchema = (
     customField: {
       isEnable:
         jsonschemas[docname][X_SIMPLEAPP_CONFIG]?.customField?.isEnable ?? false
+    },
+    miniApp: {
+      whitelistApis: miniAppWhitelistApis,
+      hasMiniAppWhitelistedApi: Object.keys(miniAppWhitelistApis).length > 0
     }
   };
 
@@ -251,7 +263,6 @@ const generateSchema = (
   const backendTargetFolder = `${backendFolder}/src/simpleapp/generate`;
   const simpleappTargetFolder = `${backendFolder}/src/simpleapp`;
   const backendServiceFolder = `${backendFolder}/src/simpleapp/services`;
-
   Object.keys(generateTypes).forEach((foldertype) => {
     //generate code for every schema
     const generateTemplatefolder = `${constants.templatedir}/basic/${foldertype}`;
@@ -590,9 +601,111 @@ const generateSchema = (
             mkdirSync(path.dirname(targetfile), { recursive: true });
           writeFileSync(targetfile, filecontent);
         }
+      } else if (foldertype === 'miniApi') {
+        processPlatformFileMiniApi(
+          resourceName,
+          docname,
+          {
+            name: filename,
+            platform: foldertype,
+            templatePath: templatepath
+          },
+          variables
+        );
+      }
+    }
+  });
+};
+
+type FileInfo = {
+  name: string;
+  platform: string;
+  templatePath: string;
+};
+
+const processPlatformFileMiniApi = (
+  resourceName: string,
+  docname: string,
+  file: FileInfo,
+  variables: any
+) => {
+  const mapfiles = {
+    'resource.service.ts.eta': {
+      to: `src/modules/resource/resources/${_.kebabCase(resourceName)}`,
+      as: `${_.kebabCase(resourceName)}.service.ts`,
+      validate: (targetfile: string, isexists: boolean) => {
+        const {
+          miniApp: { hasMiniAppWhitelistedApi }
+        } = variables;
+
+        if (!hasMiniAppWhitelistedApi) {
+          return false;
+        }
+
+        return true;
+      }
+    },
+    'resource.controller.ts.eta': {
+      to: `src/modules/resource/resources/${_.kebabCase(resourceName)}`,
+      as: `${_.kebabCase(resourceName)}.controller.ts`,
+      validate: (targetfile: string, isexists: boolean) => {
+        const {
+          miniApp: { hasMiniAppWhitelistedApi }
+        } = variables;
+
+        if (!hasMiniAppWhitelistedApi) {
+          return false;
+        }
+
+        return true;
+      }
+    },
+    'resource.module.ts.eta': {
+      to: `src/modules/resource/resources/${_.kebabCase(resourceName)}`,
+      as: `${_.kebabCase(resourceName)}.module.ts`,
+      validate: (targetfile: string, isexists: boolean) => {
+        const {
+          miniApp: { hasMiniAppWhitelistedApi }
+        } = variables;
+
+        if (!hasMiniAppWhitelistedApi) {
+          return false;
+        }
+
+        return true;
       }
     }
+  };
+
+  processPlatformFile(docname, mapfiles, file, variables);
+};
+
+const processPlatformFile = (
+  docname: string,
+  mapfiles: any,
+  file: FileInfo,
+  variables: any
+) => {
+  const eta = new Eta({
+    views: '/',
+    functionHeader: getCodeGenHelper()
   });
+
+  const target = mapfiles[file.name];
+  const targetfolder = `${generateTypes[file.platform]}/${target.to}`;
+  const targetfile = `${targetfolder}/${target.as}`;
+
+  const isexists = existsSync(targetfile);
+  const iswrite: boolean = target.validate(targetfile, isexists);
+
+  if (iswrite) {
+    if (!existsSync(targetfolder)) {
+      mkdirSync(targetfolder, { recursive: true });
+    }
+
+    const filecontent = eta.render(file.templatePath, variables);
+    writeFileSync(targetfile, filecontent);
+  }
 };
 
 const generateSystemFiles = (modules: ModuleObject[], allbpmn) => {
@@ -682,4 +795,7 @@ const prepareRoles = (groupsettings) => {
 const getCodeGenHelper = () =>
   'const capitalizeFirstLetter = (str) => !str ? `Object` : str.slice(0, 1).toUpperCase() + str.slice(1);' +
   'const initType=(str)=>{return ["string","number","boolean","array","object"].includes(str) ? capitalizeFirstLetter(str) : str;};' +
-  "const camelCaseToWords = (s) => {const result = s.replace(/([A-Z])/g, ' $1');return result.charAt(0).toUpperCase() + result.slice(1);}";
+  "const camelCaseToWords = (s) => {const result = s.replace(/([A-Z])/g, ' $1');return result.charAt(0).toUpperCase() + result.slice(1);};" +
+  'const upperFirstCase = (value) => { return value.charAt(0).toUpperCase() + value.slice(1); };' +
+  'const camelToKebab = (value) => { return value.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase(); };' +
+  'const titleCase = (value) => { return value.replace(/([a-z])([A-Z])/g, "$1 $2"); }; ';

package/src/index.ts

@@ -100,6 +100,13 @@ if (continueexecute) {
     });
   };
 
+  const runUpdateMiniApi = async () => {
+    fw.setConfiguration(configs);
+    generate.run(configs, ['miniApi'], () => {
+      fw.prettyMiniApi();
+    });
+  };
+
   const reGenFrontend = async () => {
     fw.setConfiguration(configs);
     generate.run(configs, ['nuxt'], () => {
@@ -157,6 +164,9 @@ if (continueexecute) {
     case 'updateMiniAppStreamlitSdk':
       runUpdateMiniAppStreamlitSdk();
       break;
+    case 'updateMiniApi':
+      runUpdateMiniApi();
+      break;
     case 'all':
       run();
       break;

package/src/type.ts

@@ -104,6 +104,12 @@ export type TypeGenerateDocumentVariable = {
   customField: {
     isEnable: boolean;
   };
+  miniApp: {
+    whitelistApis: {
+      [key: string]: any;
+    };
+    hasMiniAppWhitelistedApi: boolean;
+  };
 };
 
 // export type DocSetting = {

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

@@ -0,0 +1,139 @@
+<%
+  const pascalName = upperFirstCase(it.resourceName);
+  const kebabName = camelToKebab(it.resourceName);
+  const apiName = it.typename.toUpperCase() + 'Api';
+  const titleName = titleCase(pascalName);
+
+  const serviceVariable = it.resourceName + 'Service';
+%>
+
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Put,
+  Patch,
+  Param,
+  Delete,
+  Headers,
+  Query,
+} from '@nestjs/common';
+import { ApiTags, ApiBody, ApiResponse, ApiOperation, ApiQuery } from '@nestjs/swagger';
+import { ApiHeader } from 'src/types/api';
+import { <%= pascalName %>Service } from './<%= kebabName %>.service';
+
+@ApiTags('<%= titleName %>')
+@Controller('resources/<%= kebabName %>')
+export class <%= pascalName %>Controller {
+    constructor(private readonly <%= serviceVariable %>: <%= pascalName %>Service) {}
+
+    <% Object.entries(it.miniApp.whitelistApis).forEach(([action, value]) => { %>
+        <% if (value !== true && typeof value !== 'object') { return; } %>
+
+        <% if(action === 'list') { %>
+            @Get()
+            findAll(@Headers() headers:ApiHeader) {
+                return this.<%= serviceVariable %>.findAll(headers);
+            }
+        <% } else if(action === 'detail') { %>
+            @Get(':id')
+            findOne(@Headers() headers: ApiHeader, @Param('id') id: string) {
+                return this.<%= serviceVariable %>.findOne(headers, id);
+            }
+        <% } else if(action === 'create') { %>
+            @Post()
+            @ApiBody({})
+            create(
+                @Headers() headers: ApiHeader,
+                @Body() resourceDto: any,
+            ) {
+                return this.<%= serviceVariable %>.create(headers, resourceDto);
+            }
+        <% } else if(action === 'update') { %>
+            @Put(':id')
+            @ApiBody({})
+            update(
+                @Headers() headers: ApiHeader,
+                @Param('id') id: string,
+                @Body() resourceDto: any,
+            ) {
+                return this.<%= serviceVariable %>.update(headers, id, resourceDto);
+            }
+        <% } else if(action === 'patch') { %>
+            @Patch(':id')
+            @ApiBody({})
+            patch(
+                @Headers() headers: ApiHeader,
+                @Param('id') id: string,
+                @Body() resourceDto: any,
+            ) {
+                return this.<%= serviceVariable %>.patch(headers, id, resourceDto);
+            }
+        <% } else if(action === 'delete') { %>
+            @Delete(':id')
+            delete(
+                @Headers() headers: ApiHeader,
+                @Param('id') id: string,
+            ) {
+                return this.<%= serviceVariable %>.delete(headers, id);
+            }
+        <% } else if(action === 'autoComplete') { %>
+            @Post('autocomplete')
+            @ApiQuery({ name: 'query', type: String })
+            @ApiBody({ description: 'Mongo DB Filter', type: () => Object })
+            findAutocomplete(
+                @Headers() headers: ApiHeader,
+                @Query('query') query: string,
+                @Body() filter: any,
+            ) {
+                return 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 paramMatches = apiSetting.entryPoint.match(/:([\w]+)/g) || [];
+                    const paramNames = paramMatches.map(p => p.replace(':', ''));
+
+                    const args = [];
+                    const output = [];
+                    const queryParams = [];
+
+                    for (let i = 0; i < paramNames.length; i++) {
+                        const name = paramNames[i];
+                        args.push(name);
+                        output.push(name);
+                    }
+
+                    if (hasBody) {
+                        output.push('data');
+                    }
+                %>
+
+                @<%= upperFirstCase(apiSetting.method) %>('<%= apiSetting.entryPoint %>')
+                <% if (hasBody) { %>
+                    @ApiBody({ 
+                        description: 'Request Body',
+                    })
+                <% } %>
+
+                <%= action %>(
+                    @Headers() headers: ApiHeader,
+                    <% args.forEach(arg => { %>
+                        @Param('<%= arg %>') <%= arg %>: string,
+                    <% }) %>
+                    <% if (hasBody) { %>
+                        @Body() data: any,
+                    <% } %>
+                ) {
+                    return this.<%= serviceVariable %>.<%= action %>(headers, <%= output.join(', ') %>);
+                }
+            <% } %>
+        <% } %>
+        
+    <% }); %>
+}

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

@@ -0,0 +1,16 @@
+<%
+  const pascalName = upperFirstCase(it.resourceName);
+  const kebabName = camelToKebab(it.resourceName);
+%>
+
+import { Module } from '@nestjs/common';
+import { <%= pascalName %>Controller } from './<%= kebabName %>.controller';
+import { <%= pascalName %>Service } from './<%= kebabName %>.service';
+
+@Module({
+  imports: [],
+  controllers: [<%= pascalName %>Controller],
+  providers: [<%= pascalName %>Service],
+  exports: [<%= pascalName %>Service],
+})
+export class <%= pascalName %>Module {}

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

@@ -0,0 +1,109 @@
+<%
+  const pascalName = upperFirstCase(it.resourceName);
+  const apiName = it.typename.toUpperCase() + 'Api';
+%>
+
+import { BadRequestException, Injectable } from '@nestjs/common';
+import _ from 'lodash';
+import { <%= apiName %> } from 'src/openapi/backend-api';
+import { ApiHeader } from 'src/types/api';
+import { getOpenApiConfig } from 'src/utils/api';
+
+@Injectable()
+export class <%= pascalName %>Service {
+  protected guards = {
+    read: [],
+    create: [],
+    update: [],
+  };
+
+  constructor() {}
+
+  private getApi(headers: Record<string, string>) {
+    return new <%= apiName %>(getOpenApiConfig(headers));
+  }
+
+  <% Object.entries(it.miniApp.whitelistApis).forEach(([action, value]) => { %>
+    <% if (value !== true && typeof value !== 'object') { return; } %>
+    
+    <% if(action === 'list') { %>
+      async findAll(headers: ApiHeader) {
+        const api = this.getApi(headers);
+        const resp = await api.runSearch({});
+        return resp.data;
+      }
+    <% } else if(action === 'detail') { %>
+      async findOne(headers: ApiHeader, id: string) {
+        const api = this.getApi(headers);
+        const resp = await api.runFindOne(id);
+        return resp.data;
+      }
+    <% } else if(action === 'create') { %>
+      async create(headers: ApiHeader, resourceDto: any) {
+        const api = this.getApi(headers);
+        const resp = await api.runCreate(resourceDto);
+        return resp.data;
+      }
+    <% } else if(action === 'update') { %>
+      async update(headers: ApiHeader, id: string, resourceDto: any) {
+        const api = this.getApi(headers);
+        const resp = await api.runUpdate(id, resourceDto);
+        return resp.data;
+      }
+    <% } else if(action === 'patch') { %>
+      async patch(headers: ApiHeader, id: string, resourceDto: any) {
+        const api = this.getApi(headers);
+        const resp = await api.runPatch(id, resourceDto);
+        return resp.data;
+      }
+    <% } else if(action === 'delete') { %>
+      async delete(headers: ApiHeader, id: string) {
+        const api = this.getApi(headers);
+        const resp = await api.runDelete(id);
+        return resp.data;
+      }
+    <% } else if(action === 'autoComplete') { %>
+      async autocomplete(headers: ApiHeader, query: string, filter: any) {
+        const api = this.getApi(headers);
+        const resp = await api.autoComplete(query, filter);
+        return resp.data;
+      }
+    <% } 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 paramMatches = apiSetting.entryPoint.match(/:([\w]+)/g) || [];
+          const paramNames = paramMatches.map(p => p.replace(':', ''));
+
+          const args = paramNames.map(name => {
+            return `${name}: string`;
+          });
+
+          const output = [];
+          const queryParams = [];
+
+          for (let i = 0; i < paramNames.length; i++) {
+            const name = paramNames[i];
+
+            output.push(name);
+          }
+
+          if (hasBody) {
+            args.push('data: any');
+            output.push('data');
+          }
+        %>
+        
+        async <%= action %>(headers: ApiHeader, <%= args.join(', ') %>) {
+          const api = this.getApi(headers);
+          const resp = await api.run<%= upperFirstCase(action) %>(<%= output.join(', ') %>);
+          return resp.data;
+        }
+      <% } %>
+    <% } %>
+  <% }) %>
+
+}

package/templates/basic/miniAppJsSdk/resource-bridge.service.ts.eta

@@ -6,10 +6,6 @@
  */
 
 <% 
-  const upperFirstCase = (value) => {
-    return value.charAt(0).toUpperCase() + value.slice(1);
-  }
-
   const pascalName = upperFirstCase(it.resourceName);
   const apiName = it.typename.toUpperCase() + 'Api';
   const typeActionName = pascalName + 'Actions';
@@ -18,6 +14,7 @@
   const hasMiniAppWhitelistedApi = Object.keys(miniAppWhitelistApis).length > 0;
 %>
 
+import { MiniAppApiListParam } from "../../types/bridge.type";
 import { MiniAppBridgeService } from "../bridge.service";
 
 export class MiniApp<%= pascalName %>BridgeService {
@@ -33,8 +30,8 @@ export class MiniApp<%= pascalName %>BridgeService {
     <% if (value !== true && typeof value !== 'object') { return; } %>
 
     <% if(action === 'list') { %>
-      async list() {
-        return this.bridge.callApi(this.resourceName, "list");
+      async list(params?: MiniAppApiListParam | undefined) {
+        return this.bridge.callApi(this.resourceName, "list", { body: params });
       }
     <% } else if(action === 'detail') { %>
       async detail(id: string) {

package/templates/basic/miniAppStreamlitSdk/resource-bridge.service.ts.eta

@@ -1,8 +1,4 @@
 <% 
-  const upperFirstCase = (value) => {
-    return value.charAt(0).toUpperCase() + value.slice(1);
-  }
-
   const pascalName = upperFirstCase(it.resourceName);
   const apiName = it.typename.toUpperCase() + 'Api';
   const typeActionName = pascalName + 'Actions';

package/templates/basic/nest/type.ts.eta

@@ -1,10 +1,10 @@
 /**
  * This file was automatically generated by simpleapp generator. Every
  * MODIFICATION OVERRIDE BY GENERATEOR
- * last change 2024-02-23
+ * last change 2025-07-16
  * Author: Ks Tan
  */
-import {DefaultHooks} from  "../types"
+import {DefaultHooks} from  "./simpleapp.type"
 
 <% const draw = (it, obj, key, schema) => { %>
         <% if(typeof obj == 'string') {%>

package/templates/basic/nuxt/resource-bridge.editable.service.ts.eta

@@ -6,14 +6,6 @@
  */
 
 <% 
-  const upperFirstCase = (value) => {
-    return value.charAt(0).toUpperCase() + value.slice(1);
-  }
-
-  const camelToKebab = (value) => {
-    return value.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-  }
-
   const pascalName = upperFirstCase(it.resourceName);
   const kebabName = camelToKebab(it.resourceName);
   const apiName = it.typename.toUpperCase() + 'Api';

package/templates/basic/nuxt/resource-bridge.service.ts.eta

@@ -6,10 +6,6 @@
  */
 
 <% 
-  const upperFirstCase = (value) => {
-    return value.charAt(0).toUpperCase() + value.slice(1);
-  }
-
   const pascalName = upperFirstCase(it.resourceName);
   const apiName = it.typename.toUpperCase() + 'Api';
   const typeActionName = 'MiniApp' + pascalName + 'Actions';
@@ -83,7 +79,11 @@ export class MiniApp<%= pascalName %>BridgeService {
 
     <% if(action === 'list') { %>
       protected async handleList(message: MiniAppBridgeMessageApi<<%= typeActionName %>>) {
-        return (await this.api!.runSearch({})).data;
+        return (await this.api!.runSearch({
+          fields: message.params.body?.fields,
+          sorts: message.params.body?.sorts,
+          filter: message.params.body?.filters,
+        })).data;
       }
     <% } else if(action === 'detail') { %>
       protected async handleDetail(message: MiniAppBridgeMessageApi<<%= typeActionName %>>) {

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

@@ -0,0 +1,76 @@
+<%
+  const getMiniAppInfo = (module) => {
+    const schema = module.schema; 
+    const simpleAppConfig = schema['x-simpleapp-config'];
+    const miniAppWhitelistApis = simpleAppConfig?.miniApp?.whitelist || {};
+    const hasMiniAppWhitelistedApi = Object.keys(miniAppWhitelistApis).length > 0;
+    const resourcePascalName = upperFirstCase(simpleAppConfig.resourceName);
+    const resourceKebabName = camelToKebab(simpleAppConfig.resourceName);
+    const additionalApis = simpleAppConfig?.additionalApis || [];
+    let availableApis = {};
+
+    Object.entries(miniAppWhitelistApis).forEach(([action, value]) => {
+      if (value !== true && typeof value !== 'object') { return; }
+      let method = '';
+      switch(action) {
+        case 'list':
+        case 'detail':
+          method = 'get';
+          break;
+
+        case 'create':
+        case 'autoComplete':
+          method = 'post';
+          break;
+
+        case 'update':
+          method = 'put';
+          break;
+
+        case 'patch':
+          method = 'patch';
+          break;
+
+        case 'delete':
+          method = 'delete';
+          break;
+
+        case 'current':
+          return;
+          break;
+
+        default:
+          method = (additionalApis ?? []).find(item => item.action === action)?.method ?? '';
+          break;
+      }
+
+      availableApis[action] = {
+        method: method
+      }
+    });
+    
+    return {
+      miniAppWhitelistApis,
+      hasMiniAppWhitelistedApi,
+      resourceName: simpleAppConfig.resourceName,
+      resourcePascalName,
+      resourceKebabName,
+      availableApis
+    }
+  }
+
+  const modules = it.modules.sort((a, b) => a.docname.localeCompare(b.docname, undefined, { sensitivity: 'base' }));
+%>
+
+const scopes = {
+  <% modules.forEach(module => { %>
+    <% 
+      const { hasMiniAppWhitelistedApi, resourceName, miniAppWhitelistApis, availableApis } = getMiniAppInfo(module); 
+    %>
+    <% if(hasMiniAppWhitelistedApi) { %>
+      <%= resourceName %>: <%~ JSON.stringify(availableApis) %>,
+    <% } %>
+  <% }); %>
+};
+
+export default scopes;