@simitgroup/simpleapp-generator 1.6.6-n-alpha → 1.6.6-p-alpha

package/templates/nuxt/simpleapp/generate/clients/SimpleAppClient.ts.eta

@@ -77,23 +77,24 @@ export class SimpleAppClient<
   } //if there is readonly attribute in data, will override it at processor and client
   setData = (data: any) => {
     // this.data.value = data;
-    // TODO: TS ERROR
-    data.more = this._customFieldClient.processCustomFieldData(
-      // @ts-ignore
-      this.schema.properties?.["more"],
-      data.createdBy == "",
-      data.more,
-    );
+
+    // TODO: Will Cause Docno Format Broken
+    // data.more = this._customFieldClient.formCustomFieldData(
+    //   this.doctype,
+    //   this.schema.properties?.more,
+    //   data.createdBy == "",
+    //   data.more,
+    // );
 
     Object.assign(this.data.value, data);
   };
 
   async processCustomField() {
-    const resp = this._customFieldClient.processCustomField(this.doctype);
-     // TODO: TS ERROR
-    // @ts-ignore
-    this.schema.properties.more = resp.schema;
-    this.setData(this.data.value);
+    // const resp = this._customFieldClient.formCustomFieldJsonSchema(
+    //   this.doctype,
+    // );
+    // this.schema.properties.more = resp;
+    // this.setData(this.data.value);
   }
 
   async getById(id?: string) {

package/templates/nuxt/simpleapp/generate/clients/SimpleAppCustomFieldClient.ts.eta

@@ -3,74 +3,62 @@
  * MODIFICATION OVERRIDE BY GENERATEOR
  * last change 2025-06-09
  */
-import { isEmpty } from "lodash";
+import _ from "lodash";
 import {
-  CustomFieldItemJsonSchema,
-  CustomFieldJsonSchema,
-  SimpleAppJSONSchema7,
+  CustomFieldJsonSchemaMoreSchema,
+  CustomFieldJsonSchemaMoreSchemaGroup,
+  DynamicObject,
+  SimpleAppJSONSchema7Definition,
 } from "~/types";
 
-export type CustomFieldMoreDataGroup = {
-  [key: string]: CustomFieldMoreDataGroupItem;
-};
+export class SimpleAppCustomFieldClient {
+  constructor() {}
 
-export type CustomFieldMoreDataGroupItem = {
-  [key: string]: any;
-};
+  formCustomFieldJsonSchema(collectionName: string) {
+    const customFieldFromDB = this._findCustomFieldSchemaFromDB(collectionName);
+    const customFieldFromPlugin =
+      this._findCustomFieldSchemaFromPlugin(collectionName);
 
-export class SimpleAppCustomFieldClient {
-  private _defaultReturn = {
-    schema: {
+    if (customFieldFromDB && !_.isEmpty(customFieldFromDB)) {
+    }
+
+    const schema: CustomFieldJsonSchemaMoreSchema = {
       type: "object",
-      properties: {},
-    },
-  };
+      properties: {
+        ...customFieldFromDB,
+        ...customFieldFromPlugin,
+      },
+    };
 
-  constructor() {}
+    return schema;
+  }
 
-  processCustomField(collectionName: string) {
-    // console.log(collectionName, "trigger processCustomField");
+  private _findCustomFieldSchemaFromDB(collectionName: string) {
     const { $customFieldStore } = useNuxtApp();
-    if (!$customFieldStore.data || isEmpty($customFieldStore.data)) {
-      // Not Found Any Custom Field
-      return this._defaultReturn;
+    if (!$customFieldStore.data || _.isEmpty($customFieldStore.data)) {
+      return {};
     }
 
     const customField = $customFieldStore.findByCollectionName(collectionName);
     if (!customField) {
-      // Not Found Custom Field In Current collectionName
-      return this._defaultReturn;
+      return {};
     }
 
-    const schema = this._processCustomFieldMoreProperties(
-      collectionName,
-      customField.form.schema as CustomFieldItemJsonSchema,
-    );
-
-    return { schema };
-  }
-
-  private _processCustomFieldMoreProperties(
-    collectionName: string,
-    customFieldJsonSchemaString: CustomFieldItemJsonSchema | undefined,
-  ) {
-    const customFieldJsonSchema = this._processCustomFieldProperties(
-      customFieldJsonSchemaString,
-    );
-    const pluginJsonSchema =
-      this._processPluginCustomFieldProperties(collectionName);
-    return {
-      type: "object",
-      properties: {
-        ...customFieldJsonSchema,
-        ...pluginJsonSchema,
+    const schema: CustomFieldJsonSchemaMoreSchemaGroup = {
+      default: {
+        title: "Custom Field",
+        ...customField.form.schema,
       },
     };
+
+    return schema;
   }
 
-  private _processPluginCustomFieldProperties(collectionName: string) {
-    const schema: CustomFieldJsonSchema["properties"] = {};
+  private _findCustomFieldSchemaFromPlugin(collectionName: string) {
+    const schema: CustomFieldJsonSchemaMoreSchemaGroup = {};
+
     const { $appPluginsStore } = useNuxtApp();
+
     const pluginForms = $appPluginsStore.getForm(collectionName);
     if (!pluginForms || pluginForms.length <= 0) {
       return schema;
@@ -80,112 +68,121 @@ export class SimpleAppCustomFieldClient {
       const pluginItem = pluginForms[i];
       const { pluginCode, jsonSchema } = pluginItem;
 
-      schema[pluginCode] = jsonSchema as CustomFieldItemJsonSchema;
+      schema[pluginCode] = jsonSchema as SimpleAppJSONSchema7Definition;
     }
 
     return schema;
   }
 
-  private _processCustomFieldProperties(
-    customFieldJsonSchemaString: CustomFieldItemJsonSchema | undefined,
-  ) {
-    if (!customFieldJsonSchemaString) {
-      return this._defaultReturn;
-    }
-
-    return {
-      default: {
-        title: "Custom Field",
-        ...customFieldJsonSchemaString,
-      },
-    };
-  }
-
-  processCustomFieldData(
-    moreSchema: CustomFieldJsonSchema | undefined,
+  formCustomFieldData(
+    collectionName: string,
+    moreSchema: CustomFieldJsonSchemaMoreSchema | undefined,
     isNew: boolean,
-    resourceData: CustomFieldMoreDataGroup | undefined,
+    resourceData: any | undefined,
   ) {
-    const data: Record<string, any> = {};
     if (!moreSchema || !moreSchema?.properties) {
-      return data;
+      return resourceData;
     }
 
-    for (const [groupName, groupItem] of Object.entries(
-      moreSchema.properties,
-    )) {
-      let groupData: Record<string, any> = {};
-      if (groupItem.properties) {
-        groupData = this._processGroupItemData(
-          groupItem.properties,
-          isNew,
-          resourceData?.[groupName],
-        );
-      }
-
-      data[groupName] = groupData;
+    if (collectionName !== "religion") {
+      return resourceData;
     }
 
-    return data;
-  }
-
-  private _processGroupItemData(
-    groupItemProp: SimpleAppJSONSchema7 | SimpleAppJSONSchema7[] | undefined,
-    isNew: boolean,
-    resourceData: CustomFieldMoreDataGroupItem | undefined,
-  ) {
-    const data: Record<string, any> = {};
+    const data: DynamicObject = {};
 
-    if (!groupItemProp) {
-      return data;
-    }
+    if (!isNew) {
+      for (const [groupName, groupItem] of Object.entries(
+        moreSchema.properties,
+      )) {
+        const defaultData = this.generateDefaultData(groupItem);
+        const mergedData = this.mergeWithDefault(
+          defaultData,
+          resourceData?.[groupName],
+        );
 
-    for (const [fieldName, fieldItem] of Object.entries(groupItemProp)) {
-      let value;
-      if (isNew) {
-        // New Record
-        value = this._getFieldDefaultValue(fieldItem);
-      } else {
-        // Fetch By Id
-        if (resourceData?.[fieldName]) {
-          // DB got this field
-          value = resourceData?.[fieldName];
-        } else {
-          // DB don't have this field
-          value = this._getDefaultValueByType(fieldItem);
-          console.log(fieldName, value);
-        }
+        data[groupName] = mergedData;
       }
+    } else {
+      for (const [groupName, groupItem] of Object.entries(
+        moreSchema.properties,
+      )) {
+        const defaultData = this.generateDefaultData(groupItem);
 
-      data[fieldName] = value;
+        data[groupName] = defaultData;
+      }
     }
 
     return data;
   }
 
-  private _getFieldDefaultValue(fieldItem: SimpleAppJSONSchema7) {
-    return fieldItem.default !== undefined
-      ? fieldItem.default
-      : this._getDefaultValueByType(fieldItem);
-  }
+  generateDefaultData(schema: any): any {
+    if (schema.type === "object") {
+      const result: any = {};
+      if (schema?.["x-foreignkey"]) {
+        return undefined;
+      }
 
-  private _getDefaultValueByType(fieldItem: SimpleAppJSONSchema7) {
-    if (fieldItem.type === "string") {
-      return "";
+      const properties = schema.properties || {};
+      for (const key of Object.keys(properties)) {
+        result[key] = this.generateDefaultData(properties[key]);
+      }
+      return result;
     }
 
-    if (fieldItem.type === "number") {
-      return 0;
+    if (schema.type === "array") {
+      const itemSchema = schema.items;
+      const minItems = schema.minItems || 0;
+      const arr = [];
+      const itemsCount = minItems > 0 ? 1 : 0;
+      for (let i = 0; i < itemsCount; i++) {
+        arr.push(this.generateDefaultData(itemSchema));
+      }
+      return arr;
     }
 
-    if (fieldItem.type === "object") {
-      return {};
+    if (typeof schema.default !== "undefined") {
+      return schema.default;
     }
 
-    if (fieldItem.type === "array") {
-      return [];
+    // handle primitive types fallback
+    switch (schema.type) {
+      case "string":
+        return "";
+      case "number":
+      case "integer":
+        return 0;
+      case "boolean":
+        return false;
+      default:
+        return null;
     }
+  }
 
-    return "";
+  mergeWithDefault(defaultData: any, dbData: any): any {
+    if (Array.isArray(defaultData)) {
+      if (Array.isArray(dbData)) {
+        if (_.isEmpty(dbData)) {
+          return [];
+        }
+        // Merge each item
+        const mergedArray = dbData.map((dbItem, index) => {
+          const defaultItem = defaultData[index] ?? defaultData[0]; // use first default if index out of bound
+          return this.mergeWithDefault(defaultItem, dbItem);
+        });
+        return mergedArray;
+      } else {
+        // return defaultData;
+        return [];
+      }
+    } else if (typeof defaultData === "object" && defaultData !== null) {
+      const result: any = {};
+      for (const key of Object.keys(defaultData)) {
+        result[key] = this.mergeWithDefault(defaultData[key], dbData?.[key]);
+      }
+      return result;
+    } else {
+      // primitive value
+      return typeof dbData !== "undefined" ? dbData : defaultData;
+    }
   }
 }

package/templates/nuxt/simpleapp/generate/miniApp/bridge/constants/common.constant.ts.eta

@@ -0,0 +1,15 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2025-06-18
+ * Author: --
+ */
+
+export enum MINI_APP_BRIDGE_MESSAGES {
+  NAVIGATE = "NAVIGATE",
+  OPEN_ON_SCREEN_RESOURCE_FORM = "OPEN_ON_SCREEN_RESOURCE_FORM",
+  API = "API",
+  API_RESPONSE = "API_RESPONSE",
+  INIT = "INIT",
+  INIT_RESPONSE = "INIT_RESPONSE",
+}

package/templates/nuxt/simpleapp/generate/miniApp/bridge/constants/resource.constant.ts.eta

@@ -0,0 +1,46 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2025-06-18
+ * Author: --
+ */
+
+<%
+  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 getMiniAppInfo = (module) => {
+    const config = module.schema['x-simpleapp-config'];
+    const resourceName = config?.resourceName ?? config.documentName;
+
+    const pascalName = upperFirstCase(resourceName);
+    const kebabName = camelToKebab(resourceName);
+
+    const miniAppWhitelistApis = config?.miniApp?.whitelist || [];
+    const hasMiniAppWhitelistedApi = miniAppWhitelistApis.length > 0;
+
+    return {
+      resourceName, 
+      pascalName, 
+      kebabName,
+      hasMiniAppWhitelistedApi,
+      miniAppWhitelistApis,
+    }
+  }
+%>
+
+export const MINI_APP_API_RESOURCES = [
+  <% for (let i = 0; i < it.modules.length; i++) { %>
+    <%
+      const { resourceName, pascalName, hasMiniAppWhitelistedApi } = getMiniAppInfo(it.modules[i]);
+    %>
+    <% if(hasMiniAppWhitelistedApi) { %>
+      "<%= resourceName %>",
+    <% } %>
+  <% } %>
+];

package/templates/nuxt/simpleapp/generate/miniApp/bridge/services/bridge-resource-accessor.service.ts.eta

@@ -0,0 +1,63 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2025-06-18
+ * Author: --
+ */
+
+<%
+  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 getMiniAppInfo = (module) => {
+    const config = module.schema['x-simpleapp-config'];
+    const resourceName = config?.resourceName ?? config.documentName;
+
+    const pascalName = upperFirstCase(resourceName);
+    const kebabName = camelToKebab(resourceName);
+
+    const miniAppWhitelistApis = config?.miniApp?.whitelist || [];
+    const hasMiniAppWhitelistedApi = miniAppWhitelistApis.length > 0;
+
+    return {
+      resourceName, 
+      pascalName, 
+      kebabName,
+      hasMiniAppWhitelistedApi,
+      miniAppWhitelistApis,
+    }
+  }
+%>
+
+import { MiniAppResourceMap } from "../types/resource-mapper.type";
+<% for (let i = 0; i < it.modules.length; i++) { %>
+  <%
+    const { pascalName, kebabName, hasMiniAppWhitelistedApi } = getMiniAppInfo(it.modules[i]);
+  %>
+  <% if(hasMiniAppWhitelistedApi) { %>
+    import { MiniApp<%= pascalName %>BridgeService } from "../services/resources/<%= kebabName %>-bridge.service";
+  <% } %>
+<% } %>
+
+export class MiniAppBridgeResourceAccessor {
+  protected instances: Partial<MiniAppResourceMap> = {};
+
+  <% for (let i = 0; i < it.modules.length; i++) { %>
+    <%
+      const { resourceName, pascalName, kebabName, hasMiniAppWhitelistedApi } = getMiniAppInfo(it.modules[i]);
+    %>
+    <% if(hasMiniAppWhitelistedApi) { %>
+      get <%= resourceName %>() {
+        if (!this.instances.<%= resourceName %>) {
+          this.instances.<%= resourceName %> = new MiniApp<%= pascalName %>BridgeService();
+        }
+        return this.instances.<%= resourceName %>;
+      }
+    <% } %>
+  <% } %>
+}

package/templates/nuxt/simpleapp/generate/miniApp/bridge/services/bridge.service.ts.eta

@@ -0,0 +1,110 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2025-06-18
+ * Author: --
+ */
+ 
+import { SimpleAppDocumentType } from "~/types";
+import {
+  MiniAppBridgeMessageApi,
+  MiniAppBridgeMessageNavigate,
+  MiniAppBridgeMessageOpenOnScreenResourceForm,
+} from "../types/bridge.type";
+import { AxiosError } from "axios";
+import { MINI_APP_BRIDGE_MESSAGES } from "../constants/common.constant";
+import { MiniAppResourceMap } from "../types/resource-mapper.type";
+import { MiniAppBridgeResourceAccessor } from "./bridge-resource-accessor.service";
+import { MINI_APP_API_RESOURCES } from "../constants/resource.constant";
+
+export class MiniAppBridgeService extends MiniAppBridgeResourceAccessor {
+  /**************************************** Bridge Handler ***************************************/
+
+  handleBridgeNavigate(message: MiniAppBridgeMessageNavigate) {
+    goTo(message.params.target, message.params.id, message.params.query);
+  }
+
+  handleBridgeOpenOnScreenResourceForm(
+    message: MiniAppBridgeMessageOpenOnScreenResourceForm,
+  ) {
+    if (message.params.resource.id) {
+      onScreenEditDocument(
+        message.params.resource.name as SimpleAppDocumentType,
+        message.params.resource.id,
+      );
+      return;
+    }
+
+    onScreenAddDocument(message.params.resource.name as SimpleAppDocumentType, {
+      paras: message.params.data,
+    });
+    return;
+  }
+
+  async handleBridgeApi(
+    messageEvent: MessageEvent,
+    message: MiniAppBridgeMessageApi<any>,
+  ) {
+    try {
+      const data = await this.handleBridgeCallApi(message);
+
+      messageEvent.source?.postMessage(
+        {
+          type: MINI_APP_BRIDGE_MESSAGES.API_RESPONSE,
+          success: true,
+          requestId: message.requestId,
+          data,
+        },
+        {
+          targetOrigin: messageEvent.origin,
+        },
+      );
+    } catch (e) {
+      const err = e as AxiosError;
+
+      messageEvent.source?.postMessage(
+        {
+          type: MINI_APP_BRIDGE_MESSAGES.API_RESPONSE,
+          success: false,
+          requestId: message.requestId,
+          error: {
+            code: err.code,
+            message: err.message,
+            status: err.status,
+            response: err.response
+              ? {
+                  data: err.response?.data
+                    ? {
+                        data: (err.response.data as any)?.data ?? "",
+                        error: (err.response.data as any)?.error ?? "",
+                        message: (err.response.data as any)?.message ?? "",
+                        statusCode:
+                          (err.response.data as any)?.statusCode ?? "",
+                        statusMessage:
+                          (err.response.data as any)?.statusMessage ?? "",
+                      }
+                    : {},
+                  status: err.response.status,
+                  statusText: err.response.statusText,
+                }
+              : {},
+          },
+        },
+        {
+          targetOrigin: messageEvent.origin,
+        },
+      );
+    }
+  }
+
+  private async handleBridgeCallApi(message: MiniAppBridgeMessageApi<any>) {
+    const resourceName = message.params.resource.name;
+
+    if (!MINI_APP_API_RESOURCES.includes(resourceName)) {
+      throw new Error(`Unknown resource name: ${resourceName}`);
+    }
+
+    const bridge = this[resourceName as keyof MiniAppResourceMap];
+    return await bridge.handleApi(message);
+  }
+}

package/templates/nuxt/simpleapp/generate/miniApp/bridge/types/bridge.type.ts.eta

@@ -0,0 +1,72 @@
+/**
+ * This file was automatically generated by simpleapp generator. Every
+ * MODIFICATION OVERRIDE BY GENERATEOR
+ * last change 2025-06-18
+ * Author: --
+ */
+
+import { MINI_APP_BRIDGE_MESSAGES } from "../constants/common.constant";
+
+export type MiniAppResource = {
+  name: string;
+  id?: string;
+};
+
+/************************************* Bridge Message Type *************************************/
+
+export type MiniAppBridgeMessage<TAction> =
+  | MiniAppBridgeMessageNavigate
+  | MiniAppBridgeMessageOpenOnScreenResourceForm
+  | MiniAppBridgeMessageApi<TAction>
+  | MiniAppBridgeMessageInitResponse;
+
+export type MiniAppBridgeMessageNavigate = {
+  type: typeof MINI_APP_BRIDGE_MESSAGES.NAVIGATE;
+  params: {
+    target: string;
+    id?: string;
+    query?: string;
+  };
+};
+
+export type MiniAppBridgeMessageOpenOnScreenResourceForm = {
+  type: typeof MINI_APP_BRIDGE_MESSAGES.OPEN_ON_SCREEN_RESOURCE_FORM;
+  params: {
+    resource: MiniAppResource;
+    data?: any;
+  };
+};
+
+export type MiniAppBridgeMessageApi<TActions> = {
+  type: typeof MINI_APP_BRIDGE_MESSAGES.API;
+  requestId: string;
+  params: {
+    action: TActions;
+    resource: MiniAppResource;
+    /**
+     * For auto complete filter
+     */
+    query?: string;
+    /**
+     * For :id/:code/xxx
+     */
+    queryParams?: {
+      [key: string]: any;
+    };
+    body?: {
+      [key: string]: any;
+    };
+  };
+};
+
+export type MiniAppBridgeMessageApiResponse<TData> = {
+  type: typeof MINI_APP_BRIDGE_MESSAGES.API_RESPONSE;
+  requestId: string;
+  success: boolean;
+  data?: TData;
+  error?: any;
+};
+
+export type MiniAppBridgeMessageInitResponse = {
+  type: typeof MINI_APP_BRIDGE_MESSAGES.INIT_RESPONSE;
+};