@simitgroup/simpleapp-generator 1.0.1

package/src/processors/jsonschemabuilder.ts

@@ -0,0 +1,137 @@
+// import { ExceptionsHandler } from '@nestjs/core/exceptions/exceptions-handler';
+import { JSONSchema7, JSONSchema7Definition,JSONSchema7Array,JSONSchema7TypeName } from 'json-schema';
+import * as js7 from 'json-schema';
+import { capitalizeFirstLetter } from '../libs';
+import {JsonSchemaProperties} from "../type"
+// import { ConflictException } from '@nestjs/common';
+import {
+  FieldModel,
+  Fieldtypes,
+  ChildModels,
+  SchemaModel,
+} from '../type';
+import { json } from 'stream/consumers';
+
+let allmodels: ChildModels = {};
+export const readJsonSchemaBuilder = (
+  doctype: string,
+  docname: string,
+  jsondata:JSONSchema7,
+): ChildModels => {
+  allmodels = {};
+  const validateddata: JSONSchema7 = { ...jsondata };
+  let schema: SchemaModel | SchemaModel[];
+  
+  if (jsondata && jsondata.type == 'object') {
+    //no _id then need add
+    // console.log(jsondata)
+    schema = processObject(doctype,docname, jsondata)
+    // console.log("schema",schema)
+  } else if (jsondata.type == 'array') {
+    throw(`unsupport array type for ${docname}.${doctype}`)
+  }
+
+  return allmodels;
+};
+
+
+const processObject = (doctype: string,
+  docname: string,
+  jsondata:JSONSchema7,) : SchemaModel =>{
+    if(!jsondata['properties']){      
+      throw ("Invalid json schema {doctype}.{docname}, no 'properties' defined")
+    }
+    
+    //ensure some field exists, also override it
+    jsondata.properties['_id'] = {type: 'string',description: 'Control value, dont edit it',};
+    jsondata.properties['doctype'] = {type: 'string', default:doctype, examples: [doctype],description: 'Control value, dont edit it',};
+    return genSchema(
+      capitalizeFirstLetter(docname),
+      'object',
+      jsondata.properties,
+      jsondata['required'] ? jsondata['required'] : [],
+    );
+}
+
+const genSchema = (
+  docname: string,
+  schematype: string,
+  jsondata: JsonSchemaProperties|undefined,//JSONSchema7,//|JsonSchemaProperties|JSONSchema7Definition,
+  requiredlist: string[] | undefined,
+): SchemaModel => {
+  const newmodel: SchemaModel = {};
+  const props = Object.getOwnPropertyNames(jsondata);
+  // console.log('==== requirelist', requiredlist);
+  
+  for (let i = 0; i < props.length; i++) {    
+    const key = props[i];
+    
+    //below is Object.assign use for force datatype compatibility
+    const obj:JSONSchema7={}
+    Object.assign(obj,jsondata[key]);
+    const objectitem:JSONSchema7= {} as JSONSchema7    
+    Object.assign(objectitem,obj.items);
+
+    // Object.assign(objtmp,jsondata?[key]:{});
+    const isrequired = requiredlist && requiredlist.includes(key);
+    // console.log('----', key, isrequired, obj);
+    const newName: string = docname + capitalizeFirstLetter(key);
+    // console.log(key);
+    //need create sub model
+    // console.log("----",key,obj.type,objectitem.type)
+    if (obj.type == 'object') {
+      genSchema(newName, obj.type, obj.properties, obj.required);
+      newmodel[key] = newName;
+    } else if (obj.type == 'array' && obj.items && objectitem?.type == 'object') {
+      //array need submodel
+      // console.log("======",newName,key)
+      genSchema(newName, obj.type, objectitem?.properties, obj.required);
+      newmodel[key] = [newName];
+    } else if (obj.type == 'array' && objectitem?.type != 'object') {
+      //array need submodel
+      // genSchema(newName, obj.type, obj.items.properties);
+      const objecttype:string = objectitem.type?.toString() ?? 'string'
+      newmodel[key] = [objecttype];
+    } else {
+      newmodel[key] = getField(key, obj, isrequired);
+      // console.log('--------newmodel', newmodel[key]);
+    }
+  }
+  allmodels[docname] = { type: schematype, model: newmodel };
+  return newmodel;
+};
+
+const getField = (
+  fieldname: string,
+  obj: any,
+  isrequired: boolean | undefined,
+): FieldModel => {
+  let datatype: Fieldtypes = Fieldtypes.string;
+  let format = obj.format;
+  if (obj.type == 'integer') {
+    datatype = Fieldtypes.number;
+    format = 'integer';
+  }
+
+  const f: FieldModel = {
+    type: datatype,
+    // oritype: obj.type,
+    required: isrequired,
+  };
+
+  if (obj.title) f.title = obj.title;
+  if (obj.description) f.description = obj.description;
+  if (obj.format) f.format = obj.format;
+  if (obj.example) f.example = obj.example;
+  if (obj.examples) f.examples = obj.examples;
+  if (obj.default) {
+    f.default = obj.default;
+  } else {
+    if (f.type == 'string') f.default = '';
+    else if (f.type == 'number' || f.type == 'integer') f.default = 0;
+    else if (f.type == 'boolean') f.default = false;
+    else if (f.type == 'array') f.default = [];
+    else f.default = {};
+  }
+  return f;
+};

package/src/type.ts

@@ -0,0 +1,42 @@
+import { JSONSchema7, JSONSchema7Definition } from 'json-schema';
+export type ChildModels = {
+  [key: string]: { type: string; model: SchemaModel };
+};
+export enum Fieldtypes {
+  'string' = 'string',
+  'object' = 'object',
+  'array' = 'array',
+  'boolean' = 'boolean',
+  'integer' = 'integer',
+  'number' = 'number',
+}
+export type FieldModel = {
+  title?: string; //display name
+  description?: string; //small text for explain at inputs
+  default?: any;
+  type: Fieldtypes;
+  // oritype: string;
+  format?: string;
+  required?: boolean;
+  example?: any;
+  examples?: any;
+};
+
+// export type SchemaCategoryModel = {
+//   [key: string]: FieldModel;
+// };
+
+export type SchemaModel = {
+  [key: string]: string | string[] | FieldModel | SchemaModel | SchemaModel[];
+};
+
+export type JsonSchemaProperties= {
+  [key: string]: JSONSchema7Definition
+  // JSONSchema7Definition ,JSONSchema7
+}
+
+
+export type ModuleObject = {
+  doctype:string
+  docname:string
+}

package/templates/SimpleAppClient.eta

@@ -0,0 +1,111 @@
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+import { ref, Ref } from 'vue';
+import { AxiosResponse } from 'axios';
+import { JSONSchema7 } from 'json-schema';
+import { Configuration } from '../openapi';
+type crudType = {
+  runFindOne: Function;
+  runCreate: Function;
+  runUpdate: Function;
+  runList: Function;
+  runDelete: Function;
+};
+export class SimpleAppClient<
+  TData extends { _id?: string },
+  TApi extends crudType,
+> {
+  protected docapi;
+  protected data = <Ref<TData>>ref({} as TData);
+  public schema = {}; //cant define data type, cause it make autocomplete gone.
+  protected doctype = '';
+  protected errorlist = ref({});
+  constructor(apiobj: TApi) {
+    this.docapi = apiobj;
+  }
+
+  setDocType = (doctype: string) => (this.doctype = doctype);
+  setSchema = (schema: any) => (this.schema = schema);
+  getSchema = () => this.schema;
+  getErrors = () => this.errorlist;
+  getData = () => this.data.value;
+  getReactiveData = () => this.data;
+  setData = (data: any) => {
+    // this.data.value = data;
+    Object.assign(this.data.value, data);
+  };
+
+  async getById(id: string) {
+    return await this.docapi.runFindOne(id).then((res: AxiosResponse) => {
+      // this.data.value = { ...res.data };
+      Object.assign(this.data.value, res.data);
+      return res;
+    });
+  }
+  async create() {
+    const errors = this.validateFailed();
+    if (errors) {
+      return await Promise.reject(errors);
+    } else {
+      return await this.docapi
+        .runCreate(this.data.value)
+        .then((res: AxiosResponse) => {
+          this.data.value = { ...res.data };
+          return res;
+        });
+    }
+  }
+  async update() {
+    const recordid: string = this.data.value._id ?? '';
+    const errors = this.validateFailed();
+    if (errors) {
+      return await Promise.reject(errors);
+    } else {
+      return await this.docapi
+        .runUpdate(recordid, this.data.value)
+        .then((res: AxiosResponse) => {
+          return res;
+        });
+    }
+  }
+  async delete(id: string) {
+    return await this.docapi.runDelete(id);
+  }
+  async list() {
+    return await this.docapi.runList();
+  }
+  find() {}
+  hook(type: string, data: TData) {
+    console.log('internal save hook');
+    return true;
+  }
+  validateFailed() {
+    const ajv = new Ajv({ allErrors: true });
+    addFormats(ajv);
+    this.errorlist.value = {};
+    this.hook('pre-validation', this.data.value);
+    const validate = ajv.compile(this.schema);
+    const valid = validate(this.data.value);
+    if (!valid) {
+      const errors = validate.errors;
+      const tmp: { [key: string]: any } = {};
+      if (errors) {
+        for (let i = 0; i < errors?.length; i++) {
+          const key: string = errors[i]['instancePath'];
+          if (!tmp[key]) {
+            tmp[key] = [];
+          }
+          tmp[key].push(errors[i]);
+        }
+      }
+      // console.error(tmp);
+      this.errorlist.value = tmp;
+      // console.error(this.errorlist);
+
+      return validate.errors;
+    } else {
+      this.hook('post-validation', this.data.value);
+      return false;
+    }
+  }
+}

package/templates/SimpleAppController.eta

@@ -0,0 +1,66 @@
+import {
+  Controller,
+  Get,
+  Put,
+  Post,
+  Delete,
+  Body,
+  Param,
+  Type,
+} from '@nestjs/common';
+import { ApiTags, ApiBody, ApiResponse, ApiOperation } from '@nestjs/swagger';
+
+const doctype = 'person'.toUpperCase();
+type ServiceType = {
+  list: Function;
+  create: Function;
+  update: Function;
+  delete: Function;
+  findById: Function;
+  findIdThenDelete: Function;
+  findIdThenUpdate: Function;
+  setData: Function;
+};
+
+// @ApiTags(doctype)
+// @Controller(doctype.toLowerCase())
+export class SimpleAppController<TService extends ServiceType, TApiSchema, T> {
+  protected service: TService;
+  protected tryno: number;
+  //   protected apiSchemaClass=
+
+  constructor(service: TService) {
+    this.service = service;
+  }
+
+  
+  async _list() {
+    return this.service.list();
+  }
+  
+  async _findOne(id: string) {
+    const result = (await this.service.findById(id)) as TApiSchema;
+
+    return result as Type<TApiSchema>;
+  }
+
+  
+  async _create(data: TApiSchema) {
+    //const newdata: persontype.Person = { ...data };
+    const newdata: T = {} as T; //= { ...data };
+    Object.assign(newdata, data); //
+    return this.service.setData(newdata).create() as TApiSchema;
+  }
+
+  
+  async _update( id: string,data: TApiSchema) {
+    const newdata: T = {} as T; //= { ...data };
+    Object.assign(newdata, data); //
+    return this.service.findIdThenUpdate(id, newdata) as TApiSchema;
+  }
+
+ 
+  async _delete(id: string) {
+    return this.service.findIdThenDelete(id);
+  }
+}

package/templates/SimpleAppService.eta

@@ -0,0 +1,134 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import Ajv from 'ajv';
+import addFormats from 'ajv-formats';
+
+import {
+  NotFoundException,
+  InternalServerErrorException,
+} from '@nestjs/common/exceptions';
+@Injectable()
+export class SimpleAppService<T extends { _id?: string }> {
+  protected jsonschema = { type: 'object', properties: {}, required: [] };
+  protected data: T = { _id: '' } as T;
+  protected doc: Model<T>;
+  protected errorlist = [];
+  constructor(newdoc: Model<T>) {
+    this.doc = newdoc;
+  }
+  getRecordId = (): string => this.data._id;
+  setSchema = (newschema) => (this.jsonschema = newschema);
+  getSchema = () => this.doc.schema.obj;
+  getData = () => {
+    console.log('thisdata', this.data);
+    return this.data;
+  };
+  setData = (newdata: T) => {
+    delete newdata._id;
+    this.data = { ...newdata };
+    return this;
+  };
+  async list() {
+    try {
+      const products = await this.doc.find();
+      const productlist = products.map((p: T) => {
+        return p;
+      });
+      //   console.log(products);
+      return productlist;
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+  async findById(id: string) {
+    try {
+      console.log('findById', id);
+      this.data = await this.doc.findById(id);
+      console.log('findById done', this.data);
+    } catch (err) {
+      //error
+      throw new InternalServerErrorException(err.message);
+    }
+
+    if (!this.data) {
+      //data not found
+      throw new NotFoundException('Document Not found:');
+    }
+    console.log('this.data', this.data);
+    return this.data;
+    // return this;
+  }
+
+  async create() {
+    let result;
+
+    try {
+      delete this.data._id;
+      this.validateData(this.data);
+      const newdoc = new this.doc(this.data);
+      result = await newdoc.save();
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+    return result as T;
+  }
+  async update() {
+    const id: string = this.getRecordId();
+    this.findIdThenUpdate(id, this.data);
+  }
+  async delete() {
+    const id: string = this.getRecordId();
+    this.findIdThenDelete(id);
+  }
+  hook(type: string, data: T) {
+    return true;
+  }
+  validateData(data: T) {
+    const ajv = new Ajv({ allErrors: true });
+    addFormats(ajv);
+
+    if (!this.hook('pre-validation', data)) {
+      const erromsg: string[] = [];
+      for (let i = 0; i < this.errorlist.length; i++) {
+        erromsg.push(this.errorlist[i].message);
+      }
+      throw new InternalServerErrorException(erromsg.join('\n'));
+    }
+    const validate = ajv.compile(this.jsonschema);
+    const valid = validate(data);
+    if (!valid) {
+      console.log(validate.errors);
+      const erromsg: string[] = [];
+      for (let i = 0; i < validate.errors.length; i++) {
+        erromsg.push(validate.errors[i].message);
+      }
+      throw new InternalServerErrorException(erromsg.join('\n'));
+    }
+    this.hook('post-validation', data);
+  }
+
+  async findIdThenDelete(id: string) {
+    // const data = await this.findById(id);
+    try {
+      const deleteresult = await this.doc.findByIdAndDelete(id);
+      return deleteresult;
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+
+  async findIdThenUpdate(id: string, data: T) {
+    // const existingdata = await this.findById(id);
+
+    try {
+      console.log('findIdThenUpdate', id);
+      this.validateData(data);
+      // const result = await existingdata.doc.updateOne(data);
+      const result = await this.doc.findByIdAndUpdate(id, data);
+      return result;
+    } catch (err) {
+      throw new InternalServerErrorException(err.message);
+    }
+  }
+}

package/templates/app.module.eta

@@ -0,0 +1,15 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ConfigModule } from '@nestjs/config';
+
+<% for(let i=0;i<it.length; i++){ %>
+import {<%= it[i].docname %>Module} from './docs/<%= it[i].doctype %>/<%= it[i].doctype %>.module'
+<%}%>
+
+@Module({
+    //define environment variables: MONGODB_URL='mongodb://<user>:<pass>@<host>:<port>/<db>?authMechanism=DEFAULT'
+  imports: [ConfigModule.forRoot(),MongooseModule.forRoot(process.env.MONGODB_URL),<% for(let i=0;i<it.length; i++){ %><%= it[i].docname %>Module,<%}%>],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {}

package/templates/app.vue.eta

@@ -0,0 +1,21 @@
+<template>
+  <div>
+    <div>
+      <label>Firstname</label>
+      <input v-model="reactivedata.name.firstName">{{ reactivedata }}
+    </div>
+
+    <button @click="person.create().then((res)=>console.log(res.data))">try</button>
+  </div>
+</template>
+<script setup lang="ts">
+import {PersonDoc} from './server/docs/PersonDoc'
+const person = new PersonDoc()
+
+// person.update().then((res)=>console.log("dosomething"))
+// person.delete('record-id').then((res)=>console.log("dosomething"))
+// person.getById('record-id').then((res)=>console.log("dosomething"))
+// person.list().then((res)=>console.log(res))
+const noreactivedata = person.getData()
+const reactivedata = person.getReactiveData()
+</script>

package/templates/basic/apiclient.eta

@@ -0,0 +1,56 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and regenerate this file.
+ */
+import { SimpleAppClient } from '../class/SimpleAppClient';
+// import { JSONSchema7 } from 'json-schema';
+import { Configuration,
+      <%= it.doctype.toUpperCase()%>Api, 
+      <%= it.typename%> ,
+      <%Object.keys(it.schema).forEach(function(key){%>              
+        <% if(typeof it.schema[key]=='string'){%><%= it.schema[key]  %>,<%}%>
+      <%})%>
+
+    } from '../openapi';
+
+
+
+export class <%= it.typename%>Doc extends SimpleAppClient<<%= it.typename%>,<%= it.doctype.toUpperCase()%>Api>{
+  public readonly schema= <%~ JSON.stringify(it.jsonschema) %>;
+
+  constructor() {    
+    const apiconfig = new Configuration({ basePath: useRuntimeConfig().public.SIMPLEAPP_BACKEND_URL });
+    const apiobj = new <%= it.doctype.toUpperCase()%>Api(apiconfig)
+    super(apiobj)
+    
+    this.setNew();    
+  }
+  setNew = ()=>{
+    const newdata =  {
+        
+        <%Object.keys(it.schema).forEach(function(key){%>      
+          <%let field=it.schema[key]%>      
+          <% if(typeof field=='string'){%>
+            <%=key%> : <<%= field  %>>{},
+          <%} else if(field.type=='string'){%>
+              <%=key%> : '<%= field.default  %>',
+            <%} else if(Array.isArray(field)) {%>
+              <%=key%> : [],  //typeof field == array        
+            <%} else {%>
+              <%=key%> : <%=field.default%>,  //else <%= typeof field %>
+          <%}%>
+        <%})%>
+            }
+            this.setData(newdata)
+    }
+
+  /*****************************customized frontend + backend code*****************************************/
+  
+  
+  <%~ it.bothEndCode %>
+
+  /*****************************customized frontend only code*****************************************/
+
+  <%~ it.frontEndCode %>
+  }

package/templates/basic/apischema.eta

@@ -0,0 +1,29 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and regenerate this file.
+ */
+import { ApiProperty } from '@nestjs/swagger';
+
+<%Object.keys(it.models).forEach(function(name) { %>
+    <% let schema = it.models[name].model %>        
+        export class <%= name %>{            
+
+            <% Object.keys(schema).forEach(function(key){%>
+                <% let obj = schema[key] %>
+                <% if(typeof obj == 'string') {%>
+                    @ApiProperty({type: ()=><%=obj%>})
+                    <%= key %>:  <%= obj %>;                
+                <% }else if( Array.isArray( obj)){%>
+                    @ApiProperty({type: ()=>[<%=initType(obj[0]) %>] })                    
+                    <%= key %>:  <%= obj[0] %>[];
+                
+                <% }else{%>
+                    @ApiProperty(<%~ JSON.stringify(obj)%> )
+                    <%= key %>:  <%= obj.type %>;
+                <% } %>
+            <% }) %>
+        }    
+<%}) %>
+
+

package/templates/basic/backend.config.eta

@@ -0,0 +1 @@
+export const API_BASE_URL = 'http://localhost:3000';

package/templates/basic/beforesave.eta

@@ -0,0 +1,7 @@
+/**
+ * This file was automatically generated by simpleapp generator.
+ * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file,
+ * and regenerate this file.
+ */
+import { <%= it.typename %> } from './<%= it.doctype %>.type';
+export const beforeSave = (doc: <%= it.typename %>) => {}