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

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

@@ -1,147 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,128 +0,0 @@
-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

@@ -1,122 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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?' ]);
-
-  }
-
-}