@gadmin2n/schematics 0.0.70 → 0.0.71

package/src/lib/class/class.schema.d.ts

@@ -0,0 +1,32 @@
+import { Path } from '@angular-devkit/core';
+
+export interface ClassOptions {
+  /**
+   * The name of the class.
+   */
+  name: string;
+  /**
+   * The path to create the class.
+   */
+  path?: string | Path;
+  /**
+   * Application language.
+   */
+  language?: string;
+  /**
+   * The source root path.
+   */
+  sourceRoot?: string;
+  /**
+   * Specifies if a spec file is generated.
+   */
+  spec?: boolean;
+  /**
+   * Flag to indicate if a directory is created.
+   */
+  flat?: boolean;
+  /**
+   * Class name to be used internally.
+   */
+  className?: string;
+}

package/src/lib/class/files/js/__name__.js

@@ -0,0 +1 @@
+export class <%= classify(className) %> {}

package/src/lib/class/files/js/__name__.spec.js

@@ -0,0 +1,7 @@
+import { <%= classify(className) %> } from './<%= name %>';
+
+describe('<%= classify(className) %>', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(className) %>()).toBeDefined();
+  });
+});

package/src/lib/class/files/ts/__name__.spec.ts

@@ -0,0 +1,7 @@
+import { <%= classify(className) %> } from './<%= name %>';
+
+describe('<%= classify(className) %>', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(className) %>()).toBeDefined();
+  });
+});

package/src/lib/class/files/ts/__name__.ts

@@ -0,0 +1 @@
+export class <%= classify(className) %> {}

package/src/lib/client-app/angular/angular.schema.d.ts

@@ -0,0 +1,32 @@
+import { Path } from '@angular-devkit/core';
+
+export interface AngularOptions {
+  /**
+   * The name of the application.
+   */
+  name: string;
+  /**
+   * The directory of the application.
+   */
+  directory?: string;
+  /**
+   * The path to create the module.
+   */
+  path?: string;
+  /**
+   * The path to insert the module declaration.
+   */
+  module?: Path;
+  /**
+   * Flag which indicates if Angular app should be scaffolded
+   */
+  initApp?: boolean;
+  /**
+   * Metadata name affected by declaration insertion.
+   */
+  metadata?: string;
+  /**
+   * Nest element type name
+   */
+  type?: string;
+}

package/src/lib/client-app/angular/files/angular.constants.ts

@@ -0,0 +1,4 @@
+export const ANGULAR_MODULE_OPTIONS = 'ANGULAR_MODULE_OPTIONS';
+
+export const DEFAULT_ROOT_PATH = 'client/dist';
+export const DEFAULT_RENDER_PATH = '*';

package/src/lib/client-app/angular/files/angular.module.ts

@@ -0,0 +1,41 @@
+import { DynamicModule, Inject, Module, OnModuleInit } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import {
+  ANGULAR_MODULE_OPTIONS,
+  DEFAULT_RENDER_PATH,
+  DEFAULT_ROOT_PATH,
+} from './angular.constants';
+import { angularProviders } from './angular.providers';
+import { AngularModuleOptions } from './interfaces/angular-options.interface';
+import { AbstractLoader } from './loaders/abstract.loader';
+
+@Module({
+  providers: [...angularProviders],
+})
+export class AngularModule implements OnModuleInit {
+  constructor(
+    @Inject(ANGULAR_MODULE_OPTIONS)
+    private readonly ngOptions: AngularModuleOptions,
+    private readonly loader: AbstractLoader,
+    private readonly httpAdapterHost: HttpAdapterHost,
+  ) {}
+
+  public static forRoot(options: AngularModuleOptions = {}): DynamicModule {
+    options.rootPath = options.rootPath || DEFAULT_ROOT_PATH;
+    options.renderPath = options.renderPath || DEFAULT_RENDER_PATH;
+    return {
+      module: AngularModule,
+      providers: [
+        {
+          provide: ANGULAR_MODULE_OPTIONS,
+          useValue: options,
+        },
+      ],
+    };
+  }
+
+  public async onModuleInit() {
+    const httpAdapter = this.httpAdapterHost.httpAdapter;
+    this.loader.register(httpAdapter, this.ngOptions);
+  }
+}

package/src/lib/client-app/angular/files/angular.providers.ts

@@ -0,0 +1,27 @@
+import { Provider } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { AbstractLoader } from './loaders/abstract.loader';
+import { ExpressLoader } from './loaders/express.loader';
+import { FastifyLoader } from './loaders/fastify.loader';
+import { NoopLoader } from './loaders/noop.loader';
+
+export const angularProviders: Provider[] = [
+  {
+    provide: AbstractLoader,
+    useFactory: (httpAdapterHost: HttpAdapterHost) => {
+      if (!httpAdapterHost) {
+        return new NoopLoader();
+      }
+      const httpAdapter = httpAdapterHost.httpAdapter;
+      if (
+        httpAdapter &&
+        httpAdapter.constructor &&
+        httpAdapter.constructor.name === 'FastifyAdapter'
+      ) {
+        return new FastifyLoader();
+      }
+      return new ExpressLoader();
+    },
+    inject: [HttpAdapterHost],
+  },
+];

package/src/lib/client-app/angular/files/angular.utils.ts

@@ -0,0 +1,19 @@
+import { Logger } from '@nestjs/common';
+
+const MISSING_REQUIRED_DEPENDENCY = (name: string, reason: string) =>
+  `The "${name}" package is missing. Please, make sure to install this library ($ npm install ${name}) to take advantage of ${reason}.`;
+
+const logger = new Logger('PackageLoader');
+
+export function loadPackage<T = any>(
+  packageName: string,
+  context: string,
+  loaderFn?: () => T,
+): T {
+  try {
+    return loaderFn ? loaderFn() : require(packageName);
+  } catch (e) {
+    logger.error(MISSING_REQUIRED_DEPENDENCY(packageName, context));
+    process.exit(1);
+  }
+}

package/src/lib/client-app/angular/files/interfaces/angular-options.interface.ts

@@ -0,0 +1,87 @@
+export interface AngularModuleOptions {
+  /**
+   * Static files root directory.
+   * Default: "client/dist"
+   */
+  rootPath?: string;
+  /**
+   * Path to render Angular app.
+   * Default: * (wildcard - all paths)
+   */
+  renderPath?: string;
+  /**
+   * Serve static options (static files)
+   * Passed down to the underlying either `express.static` or `fastify-static.send`
+   */
+  serveStaticOptions?: {
+    /**
+     * Enable or disable setting Cache-Control response header, defaults to true.
+     * Disabling this will ignore the immutable and maxAge options.
+     */
+    cacheControl?: boolean;
+
+    /**
+     * Set how "dotfiles" are treated when encountered. A dotfile is a file or directory that begins with a dot (".").
+     * Note this check is done on the path itself without checking if the path actually exists on the disk.
+     * If root is specified, only the dotfiles above the root are checked
+     * (i.e. the root itself can be within a dotfile when when set to "deny").
+     * The default value is 'ignore'.
+     * 'allow' No special treatment for dotfiles
+     * 'deny' Send a 403 for any request for a dotfile
+     * 'ignore' Pretend like the dotfile does not exist and call next()
+     */
+    dotfiles?: string;
+
+    /**
+     * Enable or disable etag generation, defaults to true.
+     */
+    etag?: boolean;
+
+    /**
+     * Set file extension fallbacks. When set, if a file is not found, the given extensions
+     * will be added to the file name and search for.
+     * The first that exists will be served. Example: ['html', 'htm'].
+     * The default value is false.
+     */
+    extensions?: string[];
+
+    /**
+     * Enable or disable the immutable directive in the Cache-Control response header.
+     * If enabled, the maxAge option should also be specified to enable caching.
+     * The immutable directive will prevent supported clients from making conditional
+     * requests during the life of the maxAge option to check if the file has changed.
+     */
+    immutable?: boolean;
+
+    /**
+     * By default this module will send "index.html" files in response to a request on a directory.
+     * To disable this set false or to supply a new index pass a string or an array in preferred order.
+     */
+    index?: boolean | string | string[];
+
+    /**
+     * Enable or disable Last-Modified header, defaults to true. Uses the file system's last modified value.
+     */
+    lastModified?: boolean;
+
+    /**
+     * Provide a max-age in milliseconds for http caching, defaults to 0.
+     * This can also be a string accepted by the ms module.
+     */
+    maxAge?: number | string;
+
+    /**
+     * Redirect to trailing "/" when the pathname is a dir. Defaults to true.
+     */
+    redirect?: boolean;
+
+    /**
+     * Function to set custom headers on response. Alterations to the headers need to occur synchronously.
+     * The function is called as fn(res, path, stat), where the arguments are:
+     * res the response object
+     * path the file path that is being sent
+     * stat the stat object of the file that is being sent
+     */
+    setHeaders?: (res: any, path: string, stat: any) => any;
+  };
+}

package/src/lib/client-app/angular/files/loaders/abstract.loader.ts

@@ -0,0 +1,16 @@
+import { Injectable } from '@nestjs/common';
+import { AbstractHttpAdapter } from '@nestjs/core';
+import { join } from 'path';
+import { AngularModuleOptions } from '../interfaces/angular-options.interface';
+
+@Injectable()
+export abstract class AbstractLoader {
+  public abstract register(
+    httpAdapter: AbstractHttpAdapter,
+    options: AngularModuleOptions,
+  );
+
+  public getIndexFilePath(clientPath: string): string {
+    return join(clientPath, 'index.html');
+  }
+}

package/src/lib/client-app/angular/files/loaders/express.loader.ts

@@ -0,0 +1,25 @@
+import { Injectable } from '@nestjs/common';
+import { AbstractHttpAdapter } from '@nestjs/core';
+import { loadPackage } from '../angular.utils';
+import { AngularModuleOptions } from '../interfaces/angular-options.interface';
+import { AbstractLoader } from './abstract.loader';
+
+@Injectable()
+export class ExpressLoader extends AbstractLoader {
+  public register(
+    httpAdapter: AbstractHttpAdapter,
+    options: AngularModuleOptions,
+  ) {
+    const app = httpAdapter.getInstance();
+    const express = loadPackage('express', 'AngularModule', () =>
+      require('express'),
+    );
+    const clientPath = options.rootPath;
+    const indexFilePath = this.getIndexFilePath(clientPath);
+
+    app.use(express.static(clientPath, options.serveStaticOptions));
+    app.get(options.renderPath, (req: any, res: any) =>
+      res.sendFile(indexFilePath),
+    );
+  }
+}

package/src/lib/client-app/angular/files/loaders/fastify.loader.ts

@@ -0,0 +1,34 @@
+import { Injectable } from '@nestjs/common';
+import { AbstractHttpAdapter } from '@nestjs/core';
+import * as fs from 'fs';
+import { loadPackage } from '../angular.utils';
+import { AngularModuleOptions } from '../interfaces/angular-options.interface';
+import { AbstractLoader } from './abstract.loader';
+
+@Injectable()
+export class FastifyLoader extends AbstractLoader {
+  public register(
+    httpAdapter: AbstractHttpAdapter,
+    options: AngularModuleOptions,
+  ) {
+    const app = httpAdapter.getInstance();
+    const fastifyStatic = loadPackage('fastify-static', 'AngularModule', () =>
+      require('fastify-static'),
+    );
+    const { setHeaders, redirect, ...send } =
+      options.serveStaticOptions || ({} as any);
+    const clientPath = options.rootPath;
+    const indexFilePath = this.getIndexFilePath(clientPath);
+
+    app.register(fastifyStatic, {
+      root: clientPath,
+      setHeaders,
+      redirect,
+      send,
+    });
+    app.get(options.renderPath, (req: any, res: any) => {
+      const stream = fs.createReadStream(indexFilePath);
+      res.type('text/html').send(stream);
+    });
+  }
+}

package/src/lib/client-app/angular/files/loaders/noop.loader.ts

@@ -0,0 +1,12 @@
+import { Injectable } from '@nestjs/common';
+import { AbstractHttpAdapter } from '@nestjs/core';
+import { AngularModuleOptions } from '../interfaces/angular-options.interface';
+import { AbstractLoader } from './abstract.loader';
+
+@Injectable()
+export class NoopLoader extends AbstractLoader {
+  public register(
+    httpAdapter: AbstractHttpAdapter,
+    options: AngularModuleOptions,
+  ) {}
+}

package/src/lib/configuration/configuration.schema.d.ts

@@ -0,0 +1,18 @@
+export interface ConfigurationOptions {
+  /**
+   * The project where generate the configuration.
+   */
+  project: string;
+  /**
+   * The language to use in configuration (ts | js).
+   */
+  language?: string;
+  /**
+   * The collection to use in the configuration
+   */
+  collection?: string;
+  /**
+   * The source root directory
+   */
+  sourceRoot?: string;
+}

package/src/lib/configuration/files/js/nest-cli.json

@@ -0,0 +1,6 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "language": "<%= language %>",
+  "collection": "<%= collection %>",
+  "sourceRoot": "src"
+}

package/src/lib/configuration/files/ts/nest-cli.json

@@ -0,0 +1,5 @@
+{
+  "$schema": "https://json.schemastore.org/nest-cli",
+  "collection": "<%= collection %>",
+  "sourceRoot": "src"
+}

package/src/lib/controller/controller.schema.d.ts

@@ -0,0 +1,45 @@
+import { Path } from '@angular-devkit/core';
+
+export interface ControllerOptions {
+  hasGenerated?: boolean;
+  /**
+   * The name of the controller.
+   */
+  name: string;
+  /**
+   * The path to create the controller.
+   */
+  path?: string | Path;
+  /**
+   * The path to insert the controller declaration.
+   */
+  module?: Path;
+  /**
+   * Directive to insert declaration in module.
+   */
+  skipImport?: boolean;
+  /**
+   * Metadata name affected by declaration insertion.
+   */
+  metadata?: string;
+  /**
+   * Nest element type name
+   */
+  type?: string;
+  /**
+   * Application language.
+   */
+  language?: string;
+  /**
+   * The source root path
+   */
+  sourceRoot?: string;
+  /**
+   * Specifies if a spec file is generated.
+   */
+  spec?: boolean;
+  /**
+   * Flag to indicate if a directory is created.
+   */
+  flat?: boolean;
+}

package/src/lib/controller/files/js/__name__.controller.js

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller('<%= dasherize(name) %>')
+export class <%= classify(name) %>Controller {}

package/src/lib/controller/files/js/__name__.controller.spec.js

@@ -0,0 +1,18 @@
+import { Test } from '@nestjs/testing';
+import { <%= classify(name) %>Controller } from './<%= name %>.controller';
+
+describe('<%= classify(name) %> Controller', () => {
+  let controller;
+
+  beforeEach(async () => {
+    const module = await Test.createTestingModule({
+      controllers: [<%= classify(name) %>Controller],
+    }).compile();
+
+    controller = module.get(<%= classify(name) %>Controller);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

package/src/lib/controller/files/ts/__name__.controller.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { <%= classify(name) %>Controller } from './<%= name %>.controller';
+
+describe('<%= classify(name) %>Controller', () => {
+  let controller: <%= classify(name) %>Controller;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [<%= classify(name) %>Controller],
+    }).compile();
+
+    controller = module.get<<%= classify(name) %>Controller>(<%= classify(name) %>Controller);
+  });
+
+  it('should be defined', () => {
+    expect(controller).toBeDefined();
+  });
+});

package/src/lib/controller/files/ts/__name__.controller.ts

@@ -0,0 +1,137 @@
+import {
+  Inject,
+  Param,
+  Controller,
+  Get,
+  Post,
+  Body,
+  Patch,
+  Delete,
+  UseGuards,
+  ParseIntPipe,
+  NotFoundException,
+  HttpException,
+  HttpStatus,
+} from '@nestjs/common';
+import {
+  ApiCreatedResponse,
+  ApiOkResponse,
+  ApiNotFoundResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import {
+  PageOptionsDto,
+  ApiPaginatedResponse,
+  PageDto,
+  PageMetaDto,
+  ACGuard,
+  ACAttrFilter,
+  excludeEndpoint,
+  excludeController,
+} from '@gadmin2/nest-common';
+import {
+  UseRoles,
+  RolesBuilder,
+  InjectRolesBuilder,
+} from 'nest-access-control';
+<% if(hasGenerated) { %>
+import { <%= classify(name) %>Service } from '../../generated/<%= name %>/<%= name %>.service';
+import { <%= classify(name) %>Controller as Generated<%= classify(name) %>Controller } from '../../generated/<%= name %>/<%= name %>.controller';
+import { Create<%= classify(name) %>Dto } from '../../generated/<%= name %>/dto/create-<%= name %>.dto';
+import { Update<%= classify(name) %>Dto } from '../../generated/<%= name %>/dto/update-<%= name %>.dto';
+import { <%= classify(name) %>Entity } from '../../generated/<%= name %>/entities/<%= name %>.entity';
+<% } %>
+import { PrismaService } from 'nestjs-prisma';
+import { Prisma } from '@prisma/client';
+import { WINSTON_MODULE_PROVIDER } from 'nest-winston';
+import { Logger } from 'winston';
+
+import { ConfigService } from '@nestjs/config';
+
+<% if(hasGenerated) { %>
+// excludeController(Generated<%= classify(name) %>Controller);
+// excludeEndpoint(Generated<%= classify(name) %>Controller, 'deleteUinque');
+<% } %>
+
+@UseGuards(ACGuard)
+@Controller('<%= name %>')
+@ApiTags('<%= name %>')
+export class <%= classify(name) %>Controller {
+  constructor(
+    <% if(hasGenerated) { %>
+    private readonly <%= name %>Service: <%= classify(name) %>Service,
+    <% } %>
+    private prisma: PrismaService,
+    private readonly config: ConfigService,
+    @Inject(WINSTON_MODULE_PROVIDER) private readonly logger: Logger,
+    @InjectRolesBuilder() private readonly ac: RolesBuilder,
+  ) {}
+
+  /*
+  @Get('findUnique/:id')
+  @ApiOkResponse({
+    description: 'Return input id.',
+    type: String,
+  })
+  findUnique(@Param('id') id: string): string {
+    return id;
+  }
+*/
+<% if(hasGenerated) { %>
+  /*
+  @Post('create')
+  @UseRoles({
+    resource: '<%= name %>',
+    action: 'create',
+    possession: 'any',
+  })
+  @ApiCreatedResponse({ type: <%= classify(name) %>Entity })
+  async create(
+    @Body() create<%= classify(name) %>Dto: Create<%= classify(name) %>Dto,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    return new <%= classify(name) %>Entity(
+      await this.<%= name %>Service.create(acAttrFilter(create<%= classify(name) %>Dto)),
+    );
+  }
+*/
+
+  /*
+  @Patch(':id')
+  @UseRoles({
+    resource: '<%= name %>',
+    action: 'update',
+    possession: 'own',
+  })
+  @ApiOkResponse({ type: UniqueEffectedCount })
+  @ApiNotFoundResponse({
+    description: 'Cannot found this record or this record is not belong you.',
+  })
+  async updateOwn(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() update<%= classify(name) %>Dto: Update<%= classify(name) %>Dto,
+    @User() { roles, username }: UserType,
+    @ACAttrFilter() acAttrFilter,
+  ) {
+    if (!this.ac.can(roles).updateAny('<%= name %>').granted) {
+      const res = await this.<%= name %>Service.findUnique(id);
+      if(!res) {
+        throw new NotFoundException();
+      }
+
+      if (res.creator !== username) {
+        throw new HttpException('Forbidden', HttpStatus.FORBIDDEN);
+      }
+    }
+    const res = await this.<%= name %>Service.updateUnique(
+      id,
+      acAttrFilter(update<%= classify(name) %>Dto),
+    );
+    if (!res.count) {
+      throw new NotFoundException();
+    }
+    return res;
+  }
+*/
+<% } %>
+}

package/src/lib/decorator/decorator.schema.d.ts

@@ -0,0 +1,24 @@
+import { Path } from '@angular-devkit/core';
+
+export interface DecoratorOptions {
+  /**
+   * The name of the decorator.
+   */
+  name: string;
+  /**
+   * The path to create the decorator.
+   */
+  path?: string | Path;
+  /**
+   * Application language.
+   */
+  language?: string;
+  /**
+   * The source root path
+   */
+  sourceRoot?: string;
+  /**
+   * Flag to indicate if a directory is created.
+   */
+  flat?: boolean;
+}

package/src/lib/decorator/files/js/__name__.decorator.js

@@ -0,0 +1,3 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const <%= classify(name) %> = (...args) => SetMetadata('<%= name %>', args);

package/src/lib/decorator/files/ts/__name__.decorator.ts

@@ -0,0 +1,3 @@
+import { SetMetadata } from '@nestjs/common';
+
+export const <%= classify(name) %> = (...args: string[]) => SetMetadata('<%= name %>', args);

package/src/lib/filter/files/js/__name__.filter.js

@@ -0,0 +1,6 @@
+import { Catch } from '@nestjs/common';
+
+@Catch()
+export class <%= classify(name) %>Filter {
+  catch(exception, host) {}
+}

package/src/lib/filter/files/js/__name__.filter.spec.js

@@ -0,0 +1,7 @@
+import { <%= classify(name) %>Filter } from './<%= name %>.filter';
+
+describe('<%= classify(name) %>Filter', () => {
+  it('should be defined', () => {
+    expect(new <%= classify(name) %>Filter()).toBeDefined();
+  });
+});