@acorex/platform-generator 18.0.10 → 18.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acorex/platform-generator",
-  "version": "18.0.10",
+  "version": "18.0.13",
   "dependencies": {
     "@nx/devkit": "19.2.2",
     "tslib": "^2.3.0"

package/src/generators/app-module/files/project.json.template

@@ -58,35 +58,6 @@
           "commonChunk": true,
           "extractLicenses": true
         },
-        "build-test": {
-          "fileReplacements": [
-            {
-              "replace": "apps/<%= name %>/src/environments/environment.ts",
-              "with": "apps/<%= name %>/src/environments/environment.test.ts"
-            }
-          ],
-          "budgets": [
-            {
-              "type": "initial",
-              "maximumWarning": "500kb",
-              "maximumError": "5mb"
-            },
-            {
-              "type": "anyComponentStyle",
-              "maximumWarning": "200kb",
-              "maximumError": "400kb"
-            }
-          ],
-          "outputHashing": "all",
-          "sourceMap": false,
-          "optimization": true,
-          "namedChunks": false,
-          "vendorChunk": true,
-          "buildOptimizer": true,
-          "aot": true,
-          "commonChunk": true,
-          "extractLicenses": true
-        },
         "build-dev": {
           "fileReplacements": [
             {
@@ -142,32 +113,6 @@
           "sourceMap": true,
           "namedChunks": true
         },
-        "serve-test": {
-          "fileReplacements": [
-            {
-              "replace": "apps/<%= name %>/src/environments/environment.ts",
-              "with": "apps/<%= name %>/src/environments/environment.test.ts"
-            }
-          ],
-          "budgets": [
-            {
-              "type": "initial",
-              "maximumWarning": "500kb",
-              "maximumError": "8mb"
-            },
-            {
-              "type": "anyComponentStyle",
-              "maximumWarning": "200kb",
-              "maximumError": "400kb"
-            }
-          ],
-          "buildOptimizer": false,
-          "optimization": false,
-          "vendorChunk": true,
-          "extractLicenses": false,
-          "sourceMap": true,
-          "namedChunks": true
-        },
         "serve-dev": {
           "fileReplacements": [
             {
@@ -194,58 +139,6 @@
           "sourceMap": true,
           "namedChunks": true
         },
-        "serve-local": {
-          "fileReplacements": [
-            {
-              "replace": "apps/<%= name %>/src/environments/environment.ts",
-              "with": "apps/<%= name %>/src/environments/environment.local.ts"
-            }
-          ],
-          "budgets": [
-            {
-              "type": "initial",
-              "maximumWarning": "500kb",
-              "maximumError": "8mb"
-            },
-            {
-              "type": "anyComponentStyle",
-              "maximumWarning": "200kb",
-              "maximumError": "400kb"
-            }
-          ],
-          "buildOptimizer": false,
-          "optimization": false,
-          "vendorChunk": true,
-          "extractLicenses": false,
-          "sourceMap": true,
-          "namedChunks": true
-        },
-        "serve-test-local": {
-          "fileReplacements": [
-            {
-              "replace": "apps/<%= name %>/src/environments/environment.ts",
-              "with": "apps/<%= name %>/src/environments/environment.test.local.ts"
-            }
-          ],
-          "budgets": [
-            {
-              "type": "initial",
-              "maximumWarning": "500kb",
-              "maximumError": "8mb"
-            },
-            {
-              "type": "anyComponentStyle",
-              "maximumWarning": "200kb",
-              "maximumError": "400kb"
-            }
-          ],
-          "buildOptimizer": false,
-          "optimization": false,
-          "vendorChunk": true,
-          "extractLicenses": false,
-          "sourceMap": true,
-          "namedChunks": true
-        }
       },
       "defaultConfiguration": "serve:prod"
     },
@@ -255,18 +148,9 @@
         "serve-prod": {
           "browserTarget": "<%= name %>:build:serve-prod"
         },
-        "serve-test": {
-          "browserTarget": "<%= name %>:build:serve-test"
-        },
         "serve-dev": {
           "browserTarget": "<%= name %>:build:serve-dev"
         },
-        "serve-local": {
-          "browserTarget": "<%= name %>:build:serve-local"
-        },
-        "serve-test-local": {
-          "browserTarget": "<%= name %>:build:serve-test-local"
-        }
       },
       "defaultConfiguration": "development"
     },

package/src/generators/app-module/files/src/app/app.module.ts.template

@@ -10,13 +10,15 @@ import { StoreModule } from '@ngrx/store';
 import { StoreDevtoolsModule } from '@ngrx/store-devtools';
 import { AppComponent } from './app.component';
 import { appRoutes } from './app.routes';
-import { headerInterceptorInterceptor } from './header-interceptor.interceptor';
+import { BasicInterceptor } from './basic-interceptor.interceptor';
 
 import { AXFormatModule } from '@acorex/core/format';
 import { AXValidationModule } from '@acorex/core/validation';
 import {
+  AXPDexieStorageService,
   AXPImageUrlLogoConfig,
   AXPTextLogoConfig,
+  AXPStorageService,
   AXP_PLATFORM_CONFIG_TOKEN,
   configPlatform,
 } from '@acorex/platform/common';
@@ -73,7 +75,7 @@ export function initApp() {
     provideHttpClient(),
     provideRouter(appRoutes, withEnabledBlockingInitialNavigation()),
     { provide: APP_INITIALIZER, useFactory: initApp, multi: true, deps: [] },
-    { provide: HTTP_INTERCEPTORS, useClass: headerInterceptorInterceptor, multi: true },
+    { provide: HTTP_INTERCEPTORS, useClass: BasicInterceptor, multi: true },
     {
       provide: AXP_ROOT_CONFIG_TOKEN, useValue: {
         baseUrl: environment.baseUrl
@@ -92,6 +94,7 @@ export function initApp() {
           'Copyright © 2024',
       }),
     },
+    { provide: AXPStorageService, useClass: AXPDexieStorageService },
   ],
   declarations: [AppComponent],
   bootstrap: [AppComponent],

package/src/generators/app-module/files/src/app/basic-interceptor.interceptor.ts.template

@@ -0,0 +1,62 @@
+
+import { AXPSessionService } from '@acorex/platform/auth';
+import { HttpErrorResponse, HttpHandler, HttpInterceptor, HttpRequest, HttpEvent } from '@angular/common/http';
+import { inject, Injectable } from '@angular/core';
+import { Router } from '@angular/router';
+import { Observable, throwError, from } from 'rxjs';
+import { catchError, switchMap } from 'rxjs/operators';
+
+@Injectable({ providedIn: 'root' })
+export class BasicInterceptor implements HttpInterceptor {
+  private isRefreshing = false;
+
+  session = inject(AXPSessionService);
+  token = this.session.getToken();
+  router = inject(Router);
+
+  intercept(request: HttpRequest<any>, next: HttpHandler): Observable<any> {
+    let modifiedReq = request.clone();
+    if (!(request.body instanceof FormData) && !request.headers.has('Content-Type')) {
+      modifiedReq = modifiedReq.clone({ setHeaders: { 'Content-Type': 'application/json' } });
+    }
+    if (this.token) {
+      modifiedReq = modifiedReq.clone({ setHeaders: { Authorization: `Bearer ${this.token}` } });
+    }
+
+    return next.handle(modifiedReq).pipe(
+      catchError((error: HttpErrorResponse) => {
+        if (error.status === 401 && !this.isRefreshing && this.token) {
+          return this.handle401Error(modifiedReq, next);
+        } else {
+          return throwError(() => error);
+        }
+      })
+    );
+  }
+
+  private handle401Error(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
+    this.isRefreshing = true;
+
+    return from(this.session.refreshToken()).pipe(
+      switchMap((c) => {
+        this.isRefreshing = false;
+
+        const _req = request.clone({
+          setHeaders: {
+            Authorization: `Bearer ${c}`,
+          },
+        });
+
+        // Retry the request with the new token
+        return next.handle(_req);
+      }),
+      catchError(() => {
+        this.isRefreshing = false;
+        this.session.signout();
+        this.router.navigate(['auth']); // Redirect to login on failure
+        return throwError(() => new Error('Token refresh failed'));
+      })
+    );
+  }
+}
+

package/src/generators/app-module/files/src/app/modules/auth/auth-root.module.ts.template

@@ -21,7 +21,7 @@ import { <%= upperCase(name) %>Strategy } from './auth.strategy';
       provide: AXM_AUTH_CONFIG_TOKEN,
       useValue: configAuthModule({
         type: AXMAuthenticationTypes.UsernameEmailPassword,
-        oidc_settings: { ...environment.oidcConfig },
+        authConfig: { ...environment.oidcConfig },
         signinPage: {
           description: `In this kind of post, the blogger introduces a person they’ve
           interviewed and provides some background information about the

package/src/generators/app-module/files/src/app/modules/layout/entity.loader.ts.template

@@ -1,16 +1,17 @@
-import { AXPEntityConfig, AXPEntityLoader } from '@acorex/platform/common';
+import { AXPEntity } from '@acorex/platform/common';
+import { AXPEntityDefinitionLoader } from '@acorex/platform/layout/entity';
 import { Injectable, Injector, inject } from '@angular/core';
 
 @Injectable()
-export class AXPRootEntityLoader implements AXPEntityLoader {
+export class AXPRootEntityLoader implements AXPEntityDefinitionLoader {
   private injector = inject(Injector);
 
-  async get(moduleName: string, entityName: string): Promise<AXPEntityConfig | null> {
+  async get(moduleName: string, entityName: string): Promise<AXPEntity | null> {
     return new Promise(async (resolve) => {
       switch (entityName) {
         case 'sample': {
           const entity = (await import('../<%= name %>/sample/sample.entity')).entityFactory;
-          resolve(entity(this.injector));
+          resolve(entity(this.injector) as any);
           break;
         }
         default:

package/src/generators/app-module/files/src/app/modules/layout/layout-root.module.ts.template

@@ -1,73 +1,70 @@
 import {
+  AXPCommonModule,
+  AXPComponentSlotModule,
   AXPFooterTextSlotComponent,
+  AXPMenuItem,
   AXPNavBarSlotComponent,
   AXPThemeSlotComponent,
   AXP_ENTITY_LOADER,
-  AXPComponentSlotModule,
+  AXP_MENU_LOADER,
+  AXP_PLATFORM_CONFIG_TOKEN,
 } from '@acorex/platform/common';
+import { AXPLayoutModule } from '@acorex/platform/layouts';
 import { NgModule, inject } from '@angular/core';
-import { AXPRootMenuLoader } from './menu.loader';
-import { AXPRootEntityLoader } from './entity.loader';
-import { AXPCommonModule, AXPMenuItem, AXPNavigateAction, AXP_MENU_LOADER, AXP_PLATFORM_CONFIG_TOKEN } from '@acorex/platform/common';
 import pkg from '../../../../../../package.json';
-
+import { AXPRootEntityLoader } from './entity.loader';
+import { AXPRootMenuLoader } from './menu.loader';
+import { AXPEntityModule, AXP_ENTITY_DEFINITION_LOADER } from '@acorex/platform/layout/entity';
+import { AXPDefaultThemeModule } from '@acorex/platform/themes/default';
 
 @NgModule({
   imports: [
-    AXPAdminLayoutModule,
+    AXPDefaultThemeModule,
     AXPCommonModule,
     AXPLayoutModule,
+    AXPEntityModule,
     AXPComponentSlotModule.forRoot({
-      "footer-start": [
+      'footer-start': [
         {
-          name: "version",
+          name: 'version',
           component: AXPFooterTextSlotComponent,
           options: () => {
             return { text: `v${pkg.version}` };
-          }
+          },
         },
         {
-          name: "copyright",
+          name: 'copyright',
           component: AXPFooterTextSlotComponent,
           options: () => {
             const a = inject(AXP_PLATFORM_CONFIG_TOKEN);
             return { text: a.copyright };
-          }
+          },
         },
       ],
-      "auth-footer-links": [
+      'auth-footer-links': [
         {
-          name: "links",
+          name: 'links',
           component: AXPNavBarSlotComponent,
-          options: () => {
-            const items: AXPMenuItem[] = [
-              // {
-              //   text: 'About',
-              //   command: AXPNavigateAction({ payload: { commands: ['asc/help/about'] } })
-              // }
-            ];
-            return { items };
-          }
-        }      
+        },
       ],
-      "header-end": [
+      'header-end': [
         {
           name: 'theme',
           component: AXPThemeSlotComponent,
         },
       ],
-    })
+    }),
   ],
   exports: [],
   providers: [
     {
       provide: AXP_MENU_LOADER,
-      useClass: AXPRootMenuLoader
+      useClass: AXPRootMenuLoader,
     },
     {
-      provide: AXP_ENTITY_LOADER,
-      useClass: AXPRootEntityLoader
+      provide: AXP_ENTITY_DEFINITION_LOADER,
+      useClass: AXPRootEntityLoader,
     },
   ],
 })
-export class AXPLayoutRootModule { }
+export class AXPLayoutRootModule {}

package/src/generators/app-module/files/src/app/modules/layout/menu.loader.ts.template

@@ -31,7 +31,7 @@ export class AXPRootMenuLoader implements AXPMenuLoader {
       children: [
         {
           text: 'Sample Dynamic Entity',
-          path: '/<%= name %>/sample/e/sample/list',
+          path: '/<%= name %>/m/sample/e/sample/list',
         },
       ]
     },

package/src/generators/app-module/files/src/app/modules/root/mock.data.ts.template

@@ -0,0 +1,14 @@
+import { AXPDataGenerator } from '@acorex/platform/common';
+
+export const USERS = Array.from({ length: 20 }).map((_, i) => {
+  const firstName = AXPDataGenerator.firstName();
+  const lastName = AXPDataGenerator.lastName();
+  return {
+    id: AXPDataGenerator.uuid(),
+    firstname: firstName,
+    lastname: lastName,
+    phone: AXPDataGenerator.phone(),
+    email: AXPDataGenerator.email(firstName, lastName),
+    address: AXPDataGenerator.address(),
+  };
+});