@rxap/plugin-angular 20.0.1-dev.1 → 20.0.1-dev.11

package/src/generators/init-application/coerce-app-config.ts

@@ -0,0 +1,147 @@
+import { Tree } from '@nx/devkit';
+import {
+  CoerceAppConfigProvider,
+  CoerceImports,
+  ProviderObject,
+} from '@rxap/ts-morph';
+import { TsMorphAngularProjectTransform } from '@rxap/workspace-ts-morph';
+import { InitApplicationGeneratorSchema } from './schema';
+
+export function coerceAppConfig(tree: Tree, projectName: string, options: InitApplicationGeneratorSchema,) {
+  TsMorphAngularProjectTransform(tree, {
+    project: projectName,
+  }, (_, [ sourceFile ]) => {
+    const providers: Array<string | ProviderObject> = [
+      'provideRouter(appRoutes, withEnabledBlockingInitialNavigation())',
+      'provideAnimations()',
+      'ProvideErrorHandler()',
+      'ProvideEnvironment(environment)',
+    ];
+    const httpInterceptors = [
+      'HttpErrorInterceptor',
+    ];
+    const importProvidersFrom: string[] = [];
+    CoerceImports(sourceFile, [
+      {
+        moduleSpecifier: '@angular/platform-browser/animations',
+        namedImports: [ 'provideAnimations' ],
+      },
+      {
+        moduleSpecifier: '@angular/router',
+        namedImports: [ 'provideRouter', 'withEnabledBlockingInitialNavigation' ],
+      },
+      {
+        moduleSpecifier: './app.routes',
+        namedImports: [ 'appRoutes' ],
+      },
+      {
+        moduleSpecifier: '@rxap/ngx-error',
+        namedImports: [ 'ProvideErrorHandler', 'HttpErrorInterceptor' ],
+      },
+      {
+        moduleSpecifier: '@rxap/environment',
+        namedImports: [ 'ProvideEnvironment' ],
+      },
+      {
+        moduleSpecifier: '../environments/environment',
+        namedImports: [ 'environment' ],
+      },
+    ]);
+    if (options.monolithic) {
+      providers.push('ProvidePubSub()');
+      providers.push('ProvideChangelog()');
+      providers.push('provideTheme()');
+      providers.push('provideExternalApps()');
+      importProvidersFrom.push('MarkdownModule.forRoot()');
+      CoerceImports(sourceFile, [
+        {
+          moduleSpecifier: '@rxap/ngx-changelog',
+          namedImports: [ 'ProvideChangelog' ],
+        },
+        {
+          moduleSpecifier: 'ngx-markdown',
+          namedImports: [ 'MarkdownModule' ],
+        },
+        {
+          moduleSpecifier: '@rxap/ngx-pub-sub',
+          namedImports: [ 'ProvidePubSub' ],
+        },
+        {
+          moduleSpecifier: '@rxap/ngx-theme',
+          namedImports: [ 'provideTheme' ],
+        },
+        {
+          moduleSpecifier: '@rxap/layout',
+          namedImports: [ 'provideExternalApps' ],
+        }
+      ]);
+    }
+    if (options.oauth) {
+      providers.push('provideOAuthClient()');
+      providers.push('ProvideAuth()');
+      httpInterceptors.push('BearerTokenInterceptor');
+      CoerceImports(sourceFile, [
+        {
+          moduleSpecifier: 'angular-oauth2-oidc',
+          namedImports: [ 'provideOAuthClient' ],
+        },
+        {
+          moduleSpecifier: '@rxap/oauth',
+          namedImports: [ 'ProvideAuth' ],
+        },
+        {
+          moduleSpecifier: '@rxap/authentication',
+          namedImports: [ 'BearerTokenInterceptor' ],
+        },
+      ]);
+    }
+    if (options.i18n) {
+      httpInterceptors.push('LanguageInterceptor');
+      CoerceImports(sourceFile, [
+        {
+          moduleSpecifier: '@rxap/ngx-localize',
+          namedImports: [ 'LanguageInterceptor' ],
+        },
+      ]);
+    }
+    if (options.serviceWorker) {
+      providers.push(
+        `provideServiceWorker('ngsw-worker.js', { enabled: environment.serviceWorker, registrationStrategy: 'registerWhenStable:30000' })`);
+      providers.push('ProvideServiceWorkerUpdater(withDialogUpdater())');
+      CoerceImports(sourceFile, [
+        {
+          moduleSpecifier: '@angular/service-worker',
+          namedImports: [ 'provideServiceWorker' ],
+        },
+        {
+          moduleSpecifier: '@rxap/service-worker',
+          namedImports: [ 'ProvideServiceWorkerUpdater', 'withDialogUpdater' ],
+        },
+      ]);
+    }
+    if (options.material) {
+      providers.push('ProvideIconAssetPath()');
+      CoerceImports(sourceFile, [
+        {
+          moduleSpecifier: '@rxap/icon',
+          namedImports: [ 'ProvideIconAssetPath' ],
+        },
+      ]);
+    }
+    switch (options.authentication) {
+      case 'oauth2-proxy':
+        providers.push('provideOauth2Proxy()');
+        CoerceImports(sourceFile, {
+          moduleSpecifier: '@rxap/ngx-oauth2-proxy',
+          namedImports: [ 'provideOauth2Proxy' ],
+        });
+        break;
+    }
+    CoerceAppConfigProvider(sourceFile, {
+      overwrite: options.overwrite,
+      providers,
+      httpInterceptors,
+      importProvidersFrom,
+    });
+  }, [ '/app/app.config.ts' ]);
+}

package/src/generators/init-application/coerce-environment-files.ts

@@ -0,0 +1,105 @@
+import { Tree } from '@nx/devkit';
+import {
+  CoerceImports,
+  CoerceVariableDeclaration,
+} from '@rxap/ts-morph';
+import { TsMorphAngularProjectTransform } from '@rxap/workspace-ts-morph';
+import {
+  WriterFunction,
+  Writers,
+} from 'ts-morph';
+import { InitApplicationGeneratorSchema } from './schema';
+
+export function coerceEnvironmentFiles(tree: Tree, options: InitApplicationGeneratorSchema & { project: string }) {
+
+  TsMorphAngularProjectTransform(
+    tree,
+    {
+      project: options.project,
+    },
+    (project, [ sourceFile, prodSourceFile ]) => {
+
+      CoerceImports(sourceFile, {
+        moduleSpecifier: '@rxap/environment',
+        namedImports: [ 'Environment' ],
+      });
+      CoerceImports(prodSourceFile, {
+        moduleSpecifier: '@rxap/environment',
+        namedImports: [ 'Environment' ],
+      });
+
+      const baseEnvironment: Record<string, WriterFunction | string> = {
+        name: w => w.quote('development'),
+        production: 'false',
+        app: w => w.quote(options.project),
+      };
+
+      // region dev environment
+
+      if (options.serviceWorker) {
+        baseEnvironment['serviceWorker'] = 'false';
+      }
+
+      if (options.sentry) {
+        baseEnvironment['sentry'] = Writers.object({
+          enabled: 'false',
+          debug: 'false',
+        });
+      }
+
+      if (options.moduleFederation === 'host') {
+        baseEnvironment['moduleFederation'] = Writers.object({
+          manifest: w => w.quote('/module-federation.manifest.json'),
+        });
+      }
+
+      const normal = CoerceVariableDeclaration(sourceFile, 'environment', {
+        type: 'Environment',
+        initializer: Writers.object(baseEnvironment),
+      });
+
+      if (options.overwrite) {
+        normal.set({ initializer: Writers.object(baseEnvironment) });
+      }
+
+      // region
+
+      // region prod environment
+
+      if (options.moduleFederation === 'host') {
+        delete baseEnvironment['moduleFederation'];
+      }
+
+      if (options.serviceWorker) {
+        baseEnvironment['serviceWorker'] = 'true';
+      }
+
+      if (options.sentry) {
+        baseEnvironment['sentry'] = Writers.object({
+          enabled: 'true',
+          debug: 'false',
+        });
+      }
+
+      baseEnvironment['name'] = w => w.quote('production');
+      baseEnvironment['production'] = 'true';
+
+      const prod = CoerceVariableDeclaration(prodSourceFile, 'environment', {
+        type: 'Environment',
+        initializer: Writers.object(baseEnvironment),
+      });
+
+      if (options.overwrite) {
+        prod.set({ initializer: Writers.object(baseEnvironment) });
+      }
+
+      // endregion
+
+    },
+    [
+      '/environments/environment.ts?',
+      '/environments/environment.prod.ts?',
+    ],
+  );
+
+}

package/src/generators/init-application/coerce-localazy-config-file.ts

@@ -0,0 +1,26 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { CoerceFile } from '@rxap/workspace-utilities';
+import { join } from 'path';
+
+export function coerceLocalazyConfigFile(tree: Tree, project: ProjectConfiguration) {
+  const projectRoot = project.root;
+  const localazyConfigPath = join(projectRoot, 'localazy.json');
+  CoerceFile(tree, localazyConfigPath, JSON.stringify({
+    upload: {
+      type: 'xliff',
+      deprecate: 'file',
+      features: [
+        'use_defined_lang_for_source',
+        'dont_parse_target',
+      ],
+      files: 'src/i18n/messages.xlf',
+    },
+    download: {
+      includeSourceLang: true,
+      files: 'src/i18n/${languageCode}.xlf',
+    },
+  }, null, 2));
+}

package/src/generators/init-application/coerce-project.ts

@@ -0,0 +1,128 @@
+import {
+  applicationGenerator as angularApplicationGenerator,
+  E2eTestRunner,
+  host as angularHostGenerator,
+  remote as angularRemoteGenerator,
+  UnitTestRunner,
+} from '@nx/angular/generators';
+import { Schema as AngularApplicationGeneratorSchema } from '@nx/angular/src/generators/application/schema';
+import { Schema as AngularHostGeneratorSchema } from '@nx/angular/src/generators/host/schema';
+import { Schema as AngularRemoteGeneratorSchema } from '@nx/angular/src/generators/remote/schema';
+import { Tree } from '@nx/devkit';
+import {
+  GetDefaultGeneratorOptions,
+  HasProject,
+} from '@rxap/workspace-utilities';
+import { InitApplicationGeneratorSchema } from './schema';
+
+export async function CoerceProjects(tree: Tree, options: InitApplicationGeneratorSchema) {
+
+  if (!options.coerce) {
+    return;
+  }
+
+  for (const projectName of options.projects ?? []) {
+
+    if (!HasProject(tree, projectName)) {
+
+      await CoerceProject(tree, projectName, options);
+
+    }
+
+  }
+
+}
+
+export async function CoerceProject(tree: Tree, projectName: string, options: InitApplicationGeneratorSchema) {
+
+  if (HasProject(tree, projectName)) {
+    console.log(`Project ${ projectName } already exists`);
+    return;
+  }
+
+  let directory = 'user-interface';
+  if (projectName.includes('-feature-')) {
+    directory += '/feature';
+  }
+  directory += `/${ projectName.replace('user-interface-', '').replace('feature-', '') }`;
+
+  const formOptions: any = options.coerce && typeof options.coerce === 'object' ? options.coerce : {};
+
+  if (formOptions.directory && (options.projects?.length ?? 0) > 1) {
+    throw new Error('The directory option is not allowed when multiple projects are initialized!');
+  }
+
+  if (options.moduleFederation) {
+
+    if (options.moduleFederation === 'host') {
+      const defaultOptions = GetDefaultGeneratorOptions<Partial<AngularHostGeneratorSchema>>(tree, '@nx/angular:host');
+      const schema: AngularHostGeneratorSchema = {
+        style: 'scss',
+        inlineStyle: false,
+        inlineTemplate: false,
+        skipTests: false,
+        skipFormat: false,
+        skipPackageJson: false,
+        unitTestRunner: UnitTestRunner.Jest,
+        e2eTestRunner: E2eTestRunner.None,
+        linter: 'eslint',
+        strict: true,
+        standaloneConfig: true,
+        ...defaultOptions,
+        directory,
+        ...formOptions,
+        name: projectName,
+        dynamic: true,
+        projectNameAndRootFormat: 'as-provided',
+      };
+      await angularHostGenerator(tree, schema);
+    } else {
+      const defaultOptions = GetDefaultGeneratorOptions<Partial<AngularRemoteGeneratorSchema>>(tree, '@nx/angular:remote');
+      const schema: AngularRemoteGeneratorSchema = {
+        style: 'scss',
+        inlineStyle: false,
+        inlineTemplate: false,
+        skipTests: false,
+        skipFormat: false,
+        skipPackageJson: false,
+        unitTestRunner: UnitTestRunner.Jest,
+        e2eTestRunner: E2eTestRunner.None,
+        linter: 'eslint',
+        strict: true,
+        standaloneConfig: true,
+        ...defaultOptions,
+        directory,
+        ...formOptions,
+        host: options.host,
+        name: projectName,
+        projectNameAndRootFormat: 'as-provided',
+      };
+      await angularRemoteGenerator(tree, schema);
+    }
+
+  } else {
+    const defaultOptions = GetDefaultGeneratorOptions<Partial<AngularApplicationGeneratorSchema>>(tree, '@nx/angular:application');
+    const schema: AngularApplicationGeneratorSchema = {
+      style: 'scss',
+      routing: true,
+      inlineStyle: false,
+      inlineTemplate: false,
+      skipTests: false,
+      skipFormat: false,
+      skipPackageJson: false,
+      unitTestRunner: UnitTestRunner.Jest,
+      e2eTestRunner: E2eTestRunner.None,
+      linter: 'eslint',
+      strict: true,
+      standaloneConfig: true,
+      minimal: true,
+      ...defaultOptions,
+      directory,
+      ...formOptions,
+      name: projectName,
+      projectNameAndRootFormat: 'as-provided',
+    };
+    await angularApplicationGenerator(tree, schema);
+  }
+
+}

package/src/generators/init-application/generate-authentication.ts

@@ -0,0 +1,122 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceAppRoutes,
+  CoerceImports,
+  CoerceRouteGuard,
+} from '@rxap/ts-morph';
+import { TsMorphAngularProjectTransform } from '@rxap/workspace-ts-morph';
+import {
+  AddPackageJsonDependency,
+  CoerceTarget,
+  GetProject,
+  GetWorkspaceProject,
+  GetWorkspaceProjectName,
+  UpdateJsonFile,
+} from '@rxap/workspace-utilities';
+import { parseDocument } from 'yaml';
+import { InitApplicationGeneratorSchema } from './schema';
+
+async function defaultAuthentication(tree: Tree, projectName: string, project: ProjectConfiguration, options: InitApplicationGeneratorSchema) {
+
+  console.log('default authentication');
+
+  await AddPackageJsonDependency(tree, '@rxap/ngx-material-authentication', 'latest', { soft: true });
+
+  TsMorphAngularProjectTransform(tree, {
+    project: projectName,
+  }, (_, [ appSourceFile ]) => {
+    CoerceAppRoutes(appSourceFile, {
+      itemList: [
+        {
+          route: {
+            path: 'authentication',
+            loadChildren: {
+              import: '@rxap/ngx-material-authentication',
+              then: 'AUTHENTICATION_ROUTE'
+            }
+          }
+        }
+      ]
+    });
+    CoerceRouteGuard(appSourceFile, [''], 'RxapAuthenticationGuard', { routeArrayName: 'appRoutes' });
+    CoerceImports(appSourceFile, {
+      namedImports: ['RxapAuthenticationGuard'],
+      moduleSpecifier: '@rxap/authentication',
+    });
+  }, [ 'app/app.routes.ts?' ]);
+}
+
+async function oauth2ProxyAuthentication(tree: Tree, projectName: string, project: ProjectConfiguration, options: InitApplicationGeneratorSchema) {
+
+  console.log('oauth2-proxy authentication');
+
+  await AddPackageJsonDependency(tree, '@rxap/ngx-oauth2-proxy', 'latest', { soft: true });
+
+  TsMorphAngularProjectTransform(tree, {
+    project: projectName,
+  }, (_, [ appSourceFile ]) => {
+    CoerceRouteGuard(appSourceFile, [''], 'oauth2ProxyGuard', { routeArrayName: 'appRoutes' });
+    CoerceImports(appSourceFile, {
+      namedImports: ['oauth2ProxyGuard'],
+      moduleSpecifier: '@rxap/ngx-oauth2-proxy',
+    });
+  }, [ 'app/app.routes.ts?' ]);
+
+  if (tree.exists('docker-compose.yml')) {
+    const dockerComposeContent = tree.read('docker-compose.yml', 'utf-8')!;
+    const dockerCompose = parseDocument(dockerComposeContent);
+    if (dockerCompose.hasIn(['services', 'rxap-service-user'])) {
+      if (!dockerCompose.hasIn(['services', 'rxap-service-user', 'labels'])) {
+        dockerCompose.setIn(['services', 'rxap-service-user', 'labels'], [
+          'traefik.http.routers.user.middlewares=oauth-signin@docker,oauth-verify@docker'
+        ]);
+      }
+    }
+  }
+
+  if (tree.exists('shared/angular/proxy.conf.json')) {
+    UpdateJsonFile(tree, proxyConf => {
+      proxyConf['/oauth2'] ??= {
+        "target": "https://127-0-0-1.nip.io:8443",
+        "secure": false
+      };
+    }, 'shared/angular/proxy.conf.json');
+  }
+
+  const workspaceProject = GetWorkspaceProject(tree);
+  if (workspaceProject.targets && 'docker-compose' in workspaceProject.targets) {
+    CoerceTarget(workspaceProject, 'docker-compose', {
+      options: {
+        options: {
+          middlewares: [
+            'oauth-signin@docker',
+            'oauth-verify@docker',
+          ],
+        },
+      },
+    });
+  }
+
+}
+
+export async function generateAuthentication(tree: Tree, projectName: string, project: ProjectConfiguration, options: InitApplicationGeneratorSchema) {
+
+  console.log('generate authentication');
+
+  switch (options.authentication) {
+
+    default:
+    case true:
+      return defaultAuthentication(tree, projectName, project, options);
+
+    case 'oauth2-proxy':
+      return oauth2ProxyAuthentication(tree, projectName, project, options);
+
+  }
+
+
+
+}

package/src/generators/init-application/generate-monolithic.spec.ts

@@ -0,0 +1,45 @@
+import {
+  addProjectConfiguration,
+  readProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
+import { generateMonolithic } from './generate-monolithic';
+
+describe('generateMonolithic()', () => {
+
+  let tree: Tree;
+  const projectName = 'app';
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace();
+    addProjectConfiguration(tree, projectName, {
+      root: 'app',
+      sourceRoot: 'app/src',
+      projectType: 'application',
+    });
+  });
+
+  it('should generate a monolithic application configuration', () => {
+
+    generateMonolithic(tree, projectName, readProjectConfiguration(tree, projectName), {});
+    expect(tree.children('app/src/app')).toMatchSnapshot();
+    expect(tree.read('app/src/app/app.routes.ts', 'utf-8')).toMatchSnapshot();
+    expect(tree.read('app/src/app/layout.routes.ts', 'utf-8')).toMatchSnapshot();
+    expect(tree.read('app/src/app/app.navigation.ts', 'utf-8')).toMatchSnapshot();
+
+  });
+
+  it('should use MinimalLayoutComponent and no navigation when moduleFederation is host', () => {
+
+    generateMonolithic(tree, projectName, readProjectConfiguration(tree, projectName), {
+      moduleFederation: 'host',
+    });
+    expect(tree.children('app/src/app')).toMatchSnapshot();
+    expect(tree.read('app/src/app/app.routes.ts', 'utf-8')).toMatchSnapshot();
+    expect(tree.read('app/src/app/layout.routes.ts', 'utf-8')).toMatchSnapshot();
+    expect(tree.exists('app/src/app/app.navigation.ts')).toBeFalsy();
+
+  });
+
+});

package/src/generators/init-application/generate-monolithic.ts

@@ -0,0 +1,57 @@
+import {
+  ProjectConfiguration,
+  Tree,
+} from '@nx/devkit';
+import {
+  CoerceAppNavigation,
+  CoerceAppRoutes,
+  CoerceLayoutRoutes,
+} from '@rxap/ts-morph';
+import { TsMorphAngularProjectTransform } from '@rxap/workspace-ts-morph';
+import { CoerceFile } from '@rxap/workspace-utilities';
+import { join } from 'path';
+import { InitApplicationGeneratorSchema } from './schema';
+
+export function generateMonolithic(tree: Tree, projectName: string, project: ProjectConfiguration, options: InitApplicationGeneratorSchema) {
+
+  if (!project.sourceRoot) {
+    throw new Error(`Project source root not found for project ${ projectName }`);
+  }
+
+  if (!tree.exists(join(project.sourceRoot, 'assets', 'logo.png'))) {
+    if (tree.exists('logo.png')) {
+      CoerceFile(tree, join(project.sourceRoot, 'assets', 'logo.png'), tree.read('logo.png')!, true);
+    }
+  }
+
+  TsMorphAngularProjectTransform(tree, {
+    project: projectName,
+  }, (_, [ appSourceFile, layoutSourceFile ]) => {
+    CoerceLayoutRoutes(layoutSourceFile, {
+      component: options.moduleFederation === 'host' ? 'MinimalLayoutComponent' : 'LayoutComponent',
+      withNavigation: options.moduleFederation !== 'host',
+      withStatusCheckGuard: options.apiStatusCheck,
+    });
+    CoerceAppRoutes(appSourceFile, {
+      itemList: [
+        {
+          route: {
+            path: options.layoutRoutePath ?? '',
+            loadChildren: './layout.routes'
+          }
+        }
+      ]
+    });
+  }, [ 'app/app.routes.ts?', 'app/layout.routes.ts?' ]);
+
+  if (options.moduleFederation !== 'host') {
+
+    TsMorphAngularProjectTransform(tree, {
+      project: projectName,
+    }, (_, [ navigationSourceFile ]) => {
+      CoerceAppNavigation(navigationSourceFile, { overwrite: options.overwrite });
+    }, [ 'app/app.navigation.ts?' ]);
+
+  }
+
+}