@mshima/generator-jhipster-nodejs 0.0.0-stage → 0.0.1

package/generators/node-server/support/migrations.js

@@ -0,0 +1,197 @@
+import { bigDecimalPrecision } from './columns.js';
+import { serverEnumInfo } from './enums.js';
+
+/**
+ * The migrations of the SQL databases, like the Liquibase changelogs of JHipster Spring Boot: the tables of the built-in
+ * users (CreateTables), then for each entity the migration adding its table and the one adding its constraints (its
+ * foreign keys and its join tables). The tables and the columns are the ones TypeORM maps the entities to, with their
+ * names, so a database created by a former version of the application (its schema synchronized from the entities) keeps
+ * its schema.
+ *
+ * TypeORM runs the migrations in the order of the timestamp of the last 13 digits of their class name: the sections of
+ * the master.xml of Liquibase are ranges of timestamps. The changelogs of the tables are the migrations of the tables at
+ * the timestamp of the changelogDate of their entity, the changelogs of the constraints the ones of the constraints at
+ * that timestamp plus CONSTRAINTS_TIMESTAMP_OFFSET, and the changelogs of the developers, at the end of master.xml, the
+ * migrations the typeorm:migration scripts create at their time plus MIGRATION_TIMESTAMP_OFFSET.
+ */
+
+/**
+ * The offset of the timestamps of the constraints migrations, after the ones of every table: the timestamp of the
+ * constraints of an entity is the one of its table plus 3000000000000 (4702121677000 for 1702121677000), so its name, like
+ * the constraints changelog of Liquibase named by the changelogDate of the entity, never changes, whatever the entities it
+ * references. The tables of the entities created up to 95 years after the first one stay before every constraints migration.
+ */
+export const CONSTRAINTS_TIMESTAMP_OFFSET = 3 * 10 ** 12;
+
+/**
+ * The offset of the timestamps of the migrations of the developers, created by the typeorm:migration scripts: their time
+ * plus 6000000000000, after the constraints migrations of every entity created before, like the changelogs added at the
+ * end of the master.xml of Liquibase; within 13 digits until 2096.
+ */
+export const MIGRATION_TIMESTAMP_OFFSET = 6 * 10 ** 12;
+
+/** The JavaScript timestamp (milliseconds, UTC) of the changelogDate of an entity, the date JHipster parses it to. */
+const entityTimestamp = entity => entity.changelogDateForRecent.getTime();
+
+/** The TypeScript of the type of a column whose @Column decorator has none: the TypeScript type of its property. */
+const typeOfFieldType = {
+  string: 'String',
+  number: 'Number',
+  boolean: 'Boolean',
+  Date: 'Date',
+};
+
+/** A string literal of TypeScript. */
+const literal = value => `'${String(value).replaceAll('\\', '\\\\').replaceAll("'", "\\'")}'`;
+
+/** The migration column of the primary key of an entity, like its @PrimaryGeneratedColumn. */
+export const primaryKeyColumn = entity => ({
+  name: entity.primaryKey.name,
+  type: entity.primaryKey.typeUUID ? literal('uuid') : 'Number',
+  primary: true,
+  generated: entity.primaryKey.typeUUID ? 'uuid' : 'increment',
+});
+
+/** The migration column referencing the primary key of an entity: a join column, or a column of a join table. */
+const referenceColumn = (name, entity) => ({
+  name,
+  type: entity.primaryKey.typeUUID ? literal('uuid') : 'Number',
+});
+
+/** The migration columns of a field, like the @Column decorators of the entity: its column, and the content type of a blob. */
+export const fieldColumns = field => {
+  const { fieldValidationRequired: required, fieldValidationUnique: unique, fieldValidationMaxlength: maxlength } = field;
+  const nullable = !required;
+  const type = field.nodejsColumnType ? literal(field.nodejsColumnType) : (typeOfFieldType[field.nodejsFieldType] ?? 'String');
+  const column = { name: field.fieldNameAsDatabaseColumn, type, nullable, unique };
+  if (field.fieldIsEnum) {
+    // The values of the TypeScript enum of the field, the ones of the enum column of the databases having one (MySQL).
+    column.enum = `[${serverEnumInfo(field)
+      .enumValues.map(({ value }) => literal(value))
+      .join(', ')}]`;
+  } else if (field.fieldType === 'BigDecimal') {
+    Object.assign(column, bigDecimalPrecision);
+  } else if (!['Instant', 'ZonedDateTime', 'LocalDate'].includes(field.fieldType) && maxlength) {
+    column.length = field.fieldValidateRulesMaxlength;
+  }
+  const columns = [column];
+  if (['byte[]', 'ByteBuffer'].includes(field.fieldType) && field.fieldTypeBlobContent !== 'text') {
+    columns.push({ name: `${field.fieldNameAsDatabaseColumn}_content_type`, type: 'String', nullable });
+  }
+  return columns;
+};
+
+/**
+ * The camelCase of the default naming strategy of TypeORM, the names it gives the join columns and the columns of the join
+ * tables: unlike the one of lodash, it keeps the case of the letters it does not join (mainURL_id is mainURLId).
+ */
+export const typeormCamelCase = text =>
+  text.replaceAll(/^([A-Z])|[\s\-_](\w)/g, (_match, first, next) => (next ? next.toUpperCase() : first.toLowerCase()));
+
+/** The join column of a relationship, named like TypeORM names it (the relationship and the primary key of the other entity). */
+const joinColumnName = relationship =>
+  typeormCamelCase(`${relationship.relationshipFieldName}_${relationship.otherEntity.primaryKey.name}`);
+
+/**
+ * The relationships of an entity with a join column, the persistableRelationships of JHipster but the many-to-many ones:
+ * the many-to-one ones, and the one-to-one ones on their owner side.
+ */
+const joinColumnRelationships = entity => entity.persistableRelationships.filter(relationship => !relationship.relationshipManyToMany);
+
+/**
+ * The names of the columns of a join table, like TypeORM names the ones of a @JoinTable: the same names, like the ones of a
+ * many-to-many relationship of an entity with itself named like its table, suffixed by _1 and _2.
+ */
+const junctionColumnNames = (joinColumnName, inverseJoinColumnName) =>
+  joinColumnName === inverseJoinColumnName
+    ? [`${joinColumnName}_1`, `${inverseJoinColumnName}_2`]
+    : [joinColumnName, inverseJoinColumnName];
+
+/** The relationships of an entity with a join table, the many-to-many ones on their owner side (shouldWriteJoinTable of JHipster). */
+const joinTableRelationships = entity => entity.relationships.filter(relationship => relationship.shouldWriteJoinTable);
+
+/**
+ * The join table of a many-to-many relationship on its owner side, the one of its @JoinTable and of its constraints
+ * migration: the joinTable of JHipster, its columns named by the table of the entity and the relationship.
+ */
+export const joinTable = (entity, relationship) => {
+  const [joinColumnName, inverseJoinColumnName] = junctionColumnNames(`${entity.entityTableName}_id`, `${relationship.columnName}_id`);
+  return {
+    name: relationship.joinTable.name,
+    joinColumn: {
+      ...referenceColumn(joinColumnName, entity),
+      referencedTableName: entity.entityTableName,
+      referencedColumnName: entity.primaryKey.name,
+    },
+    inverseJoinColumn: {
+      ...referenceColumn(inverseJoinColumnName, relationship.otherEntity),
+      referencedTableName: relationship.otherEntity.entityTableName,
+      referencedColumnName: relationship.otherEntity.primaryKey.name,
+    },
+  };
+};
+
+/** The migration adding the table of an entity, its name, its class and its columns. */
+export const entityMigration = entity => {
+  const timestamp = entityTimestamp(entity);
+  const relationships = joinColumnRelationships(entity);
+  return {
+    timestamp,
+    className: `AddedEntity${entity.entityClass}${timestamp}`,
+    fileName: `${timestamp}-AddedEntity${entity.entityClass}`,
+    tableName: entity.entityTableName,
+    columns: [
+      primaryKeyColumn(entity),
+      ...entity.fields.filter(field => !field.id).flatMap(fieldColumns),
+      ...relationships.map(relationship => ({
+        ...referenceColumn(joinColumnName(relationship), relationship.otherEntity),
+        nullable: true,
+      })),
+    ],
+    relationUniques: relationships
+      .filter(relationship => relationship.relationshipOneToOne)
+      .map(relationship => joinColumnName(relationship)),
+  };
+};
+
+/**
+ * The migration adding the constraints of an entity, its foreign keys and its join tables, when it has some: run after the
+ * migrations of every table, like the constraints changelogs of JHipster run after every table.
+ */
+export const constraintsMigration = entity => {
+  const joinColumns = joinColumnRelationships(entity);
+  const joinTables = joinTableRelationships(entity);
+  if (joinColumns.length === 0 && joinTables.length === 0) return undefined;
+  const timestamp = entityTimestamp(entity) + CONSTRAINTS_TIMESTAMP_OFFSET;
+  return {
+    timestamp,
+    className: `AddedEntityConstraints${entity.entityClass}${timestamp}`,
+    fileName: `${timestamp}-AddedEntityConstraints${entity.entityClass}`,
+    tableName: entity.entityTableName,
+    foreignKeys: joinColumns.map(relationship => ({
+      columnName: joinColumnName(relationship),
+      referencedTableName: relationship.otherEntity.entityTableName,
+      referencedColumnName: relationship.otherEntity.primaryKey.name,
+    })),
+    joinTables: joinTables.map(relationship => joinTable(entity, relationship)),
+  };
+};
+
+/**
+ * The join table of the authorities of the built-in users, named like TypeORM names the junction table of the @JoinTable()
+ * of User.authorities: the tables and the property, its columns the tables and their primary keys.
+ */
+export const userAuthorityJoinTable = ({ user, authority }) => ({
+  name: `${user.entityTableName}_authorities_${authority.entityTableName}`,
+  joinColumn: {
+    ...referenceColumn(typeormCamelCase(`${user.entityTableName}_${user.primaryKey.name}`), user),
+    referencedTableName: user.entityTableName,
+    referencedColumnName: user.primaryKey.name,
+  },
+  inverseJoinColumn: {
+    name: typeormCamelCase(`${authority.entityTableName}_name`),
+    type: 'String',
+    referencedTableName: authority.entityTableName,
+    referencedColumnName: 'name',
+  },
+});

package/generators/node-server/support/validators.js

@@ -0,0 +1,25 @@
+/** An ISO-8601 duration, like Duration.parse of Java: the pattern of parseDuration (src/common/database/column-transformers.ts). */
+const ISO_DURATION = String.raw`/^([-+]?)P(?:([-+]?\d+)D)?(?:T(?:([-+]?\d+)H)?(?:([-+]?\d+)M)?(?:([-+]?)(\d+)(?:[.,](\d{0,9}))?S)?)?$/i`;
+
+/**
+ * The class-validator decorators of the type of each field type, like the JSON deserialization of JHipster Spring Boot refuses
+ * a value of another type (400), instead of the error of the database or of a column transformer (500): a number, a
+ * boolean, a UUID, an ISO-8601 instant, a yyyy-MM-dd date, a HH:mm:ss time or an ISO-8601 duration.
+ */
+const typeValidators = {
+  Integer: ['@IsInt()'],
+  Long: ['@IsInt()'],
+  Float: ['@IsNumber()'],
+  Double: ['@IsNumber()'],
+  BigDecimal: ['@IsNumber()'],
+  Boolean: ['@IsBoolean()'],
+  UUID: ['@IsUUID()'],
+  Instant: ['@IsISO8601()'],
+  ZonedDateTime: ['@IsISO8601()'],
+  LocalDate: [String.raw`@Matches(/^\d{4}-\d{2}-\d{2}$/)`, '@IsISO8601({ strict: true })'],
+  LocalTime: [String.raw`@Matches(/^\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?$/)`],
+  Duration: [`@Matches(${ISO_DURATION})`],
+};
+
+/** The class-validator decorators of the type of a field: none for a text, a blob or an enum (@IsEnum). */
+export const fieldTypeValidators = field => (field.fieldIsEnum ? [] : (typeValidators[field.fieldType] ?? []));

package/generators/node-server/templates/.dockerignore.ejs

@@ -0,0 +1,16 @@
+.git
+Dockerfile
+.dockerignore
+node_modules
+yarn.lock
+
+<%= nodeServerRootDir %>node_modules
+<%= nodeServerRootDir %>dist
+<%= nodeServerRootDir %>.env
+<%= nodeServerRootDir %>yarn.lock
+
+<%= clientRootDir %>node_modules
+<%= clientRootDir %>yarn.lock
+
+<%= temporaryDir %>
+target

package/generators/node-server/templates/.gitignore.jhi.nodejs.ejs

@@ -0,0 +1,24 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<&_ if (!fragment.section) { -&>
+# Generated by jhipster-nodejs:node-server
+<%- nodeServerRootDir %>dist/
+# Local settings of the server, like secrets (the development profile is in .env.dev)
+<%- nodeServerRootDir %>.env
+<&_ } -&>

package/generators/node-server/templates/Dockerfile.ejs

@@ -0,0 +1,54 @@
+<%_
+const serverDir = nodeServerRootDir.replace(/\/$/, '');
+const clientDir = clientRootDir.replace(/\/$/, '');
+_%>
+# Build stage: installs every dependency and builds the application.
+FROM node:<%- nodeVersion %>-alpine AS build
+
+WORKDIR /usr/src/app
+
+# The package-lock.json of the application, missing in a workspace of applications (its lock is the one of the workspace).
+COPY package*.json ./
+COPY <%- nodeServerRootDir %>package.json <%- nodeServerRootDir %>
+<%_ if (clientFrameworkAny) { _%>
+COPY <%- clientRootDir %>package.json <%- clientRootDir %>
+<%_ } _%>
+# The install scripts (native bindings of the development database, husky, Cypress) are not needed to build. npm install
+# installs the versions of the package-lock.json, or resolves them and writes one, the runtime stage installs from it.
+RUN npm install --ignore-scripts
+
+COPY . .
+RUN npm run build --workspace <%- serverDir %>
+<%_ if (clientFrameworkAny) { _%>
+# The client is built into <%- nodeServerRootDir %>dist/static, served by the server.
+RUN npm run build --workspace <%- clientDir %>
+<%_ } _%>
+
+# Runtime stage: the production dependencies of the server and its build only.
+FROM node:<%- nodeVersion %>-alpine
+
+WORKDIR /usr/src/app
+
+ENV NODE_ENV=production
+ENV BACKEND_ENV=prod
+ENV NODE_SERVER_PORT=<%- serverPort %>
+
+COPY package.json ./
+COPY --from=build /usr/src/app/package-lock.json ./
+COPY <%- nodeServerRootDir %>package.json <%- nodeServerRootDir %>
+<%_ if (clientFrameworkAny) { _%>
+COPY <%- clientRootDir %>package.json <%- clientRootDir %>
+<%_ } _%>
+RUN npm ci --omit=dev --ignore-scripts --workspace <%- serverDir %> && npm cache clean --force
+
+COPY --from=build /usr/src/app/<%- nodeServerRootDir %>dist <%- nodeServerRootDir %>dist
+
+USER node
+WORKDIR /usr/src/app/<%- serverDir %>
+
+EXPOSE <%- serverPort %>
+
+HEALTHCHECK --interval=10s --timeout=5s --start-period=30s --retries=5 \
+  CMD ["node", "-e", "fetch(`http://localhost:${process.env.NODE_SERVER_PORT}/management/health`).then(r => process.exit(r.ok ? 0 : 1), () => process.exit(1))"]
+
+CMD ["node", "dist/main.js"]

package/generators/node-server/templates/README.md.jhi.nodejs.ejs

@@ -0,0 +1,220 @@
+<%#
+ Copyright 2019-2023 the original author or authors from the JHipster project
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<%#
+ This is a fragment file, it will be merged into to root template if available.
+ EJS fragments will process % delimiter tags in template and & delimiter tags in the merge process.
+-%>
+<&_ if (fragment.introSection) { -&>
+This application was generated using the [NodeJS blueprint](https://github.com/jhipster/generator-jhipster-nodejs) of JHipster <%= jhipsterVersion %>, you can find documentation and help at [<%= documentationArchiveUrl %>](<%= documentationArchiveUrl %>). For any questions you can refer to the stream lead: [Angelo Manganiello](https://github.com/amanganiello90).
+<%_ if (applicationTypeGateway || applicationTypeMicroservice) { _%>
+
+This is a "<%= applicationType %>" application intended to be part of a microservice architecture, please refer to the [Doing microservices with JHipster][] page of the documentation for more information.
+<%_ if (serviceDiscoveryEureka) { _%>
+This application is configured for Service Discovery and Configuration with the JHipster-Registry, enabled with `EUREKA_CLIENT_ENABLED=true` (at `eureka.client.service-url.defaultZone`, [http://localhost:8761](http://localhost:8761) by default). Enabled, it refuses to start if it is not able to load its configuration from the JHipster-Registry, then registers once it listens and deregisters when it stops. For more information, read our documentation on [Service Discovery and Configuration with the JHipster-Registry][].
+<%_ } _%>
+<%_ if (serviceDiscoveryConsul) { _%>
+This application is configured for Service Discovery with Consul, enabled with `CLOUD_CONSUL_ENABLED=true` (at `CLOUD_CONSUL_HOST` and `CLOUD_CONSUL_PORT`, [http://localhost:8500](http://localhost:8500) by default). Enabled, it registers once it listens, with the health check of `/management/health`, and deregisters when it stops; a failed registration is logged. For more information, read our documentation on [Service Discovery and Configuration with Consul][].
+<%_ } _%>
+<%_ } _%>
+
+<&_ } -&>
+
+<&_ if (fragment.structureSection) { -&>
+Node is required for generation and recommended for development. `package.json` is always generated for a better development experience with prettier, commit hooks, scripts and so on.
+
+In the project root, JHipster generates configuration files for tools like git, prettier, husky, and others that are well known and you can find references in the web.
+
+- `.yo-rc.json` - Yeoman configuration file
+JHipster configuration is stored in this file at `generator-jhipster` key. You may find `generator-jhipster-*` for specific blueprints configuration.
+- `.yo-resolve` (optional) - Yeoman conflict resolver
+Allows to use a specific action when conflicts are found skipping prompts for files that matches a pattern. Each line should match `[pattern] [action]` with pattern been a [Minimatch](https://github.com/isaacs/minimatch#minimatch) pattern and action been one of skip (default if ommited) or force. Lines starting with `#` are considered comments and are ignored.
+- `.jhipster/*.json` - JHipster entity configuration files
+- `/<%- dockerServicesDir %>` - Docker configurations for the application and services that the application depends on
+- `/<%- clientRootDir %>` - Web application.
+- `/server/` - NodeJS server application.
+
+<&_ } -&>
+
+<&_ if (fragment.developmentSection) { -&>
+
+<%_ if (authenticationTypeOauth2) { _%>
+### OAuth 2.0 / OpenID Connect
+
+Congratulations! You've selected an excellent way to secure your NHipster application. If you're not sure what OAuth and OpenID Connect (OIDC) are, please see [What the Heck is OAuth?](https://developer.okta.com/blog/2017/06/21/what-the-heck-is-oauth)
+
+To log in to your app, you'll need to have [Keycloak](https://keycloak.org) up and running. The JHipster Team has created a Docker container for you that has the default users and roles. Start Keycloak using the following command.
+
+```
+docker compose -f <%- dockerServicesDir %>keycloak.yml up
+```
+
+### Okta
+
+If you'd like to use Okta instead of Keycloak, it's pretty quick using the [Okta CLI](https://cli.okta.com/). After you've installed it, run:
+
+```shell
+okta register
+```
+
+Then, in your JHipster app's directory, run `okta apps create` and select **JHipster**. This will set up an Okta app for you, create `ROLE_ADMIN` and `ROLE_USER` groups, create a `.okta.env` file with your Okta settings, and configure a `groups` claim in your ID token.
+
+Run `source .okta.env` and start your app with `npm start`. You should be able to sign in with the credentials you registered with.
+
+If you're on Windows, you should install [WSL](https://docs.microsoft.com/en-us/windows/wsl/install-win10) so the `source` command will work.
+
+If you'd like to configure things manually through the Okta developer console, see the instructions below.
+
+First, you'll need to create a free developer account at <https://developer.okta.com/signup/>. After doing so, you'll get your own Okta domain, that has a name like `https://dev-123456.okta.com`.
+
+Modify `<%= nodeServerRootDir %>src/config/application.yml` to use your Okta settings.
+
+```yaml
+  ...
+  security:
+    oauth2:
+      client:
+        provider:
+          oidc:
+            issuer-uri: https://{yourOktaDomain}/oauth2/default
+        registration:
+          oidc:
+            client-id: {clientId}
+            client-secret: {clientSecret}
+```
+
+Create an OIDC App in Okta to get a `{clientId}` and `{clientSecret}`. To do this, log in to your Okta Developer account and navigate to **Applications** > **Add Application**. Click **Web** and click the **Next** button. Give the app a name you’ll remember, specify `http://localhost:<%- serverPort %>` as a Base URI, and `http://localhost:<%- serverPort %>/login/oauth2/code/oidc` as a Login Redirect URI. Click **Done**, then Edit and add `http://localhost:<%- serverPort %>` as a Logout redirect URI. Copy and paste the client ID and secret into your `application.yml` file.
+
+Create a `ROLE_ADMIN` and `ROLE_USER` group and add users into them. Modify e2e tests to use this account when running integration tests. You'll need to change credentials in `<%= clientTestDir %>e2e/account/account.spec.ts` and `<%= clientTestDir %>e2e/admin/administration.spec.ts`.
+
+Navigate to **API** > **Authorization Servers**, click the **Authorization Servers** tab and edit the default one. Click the **Claims** tab and **Add Claim**. Name it "groups", and include it in the ID Token. Set the value type to "Groups" and set the filter to be a Regex of `.*`.
+
+After making these changes, you should be good to go! If you have any issues, please post them to [Stack Overflow](https://stackoverflow.com/questions/tagged/jhipster). Make sure to tag your question with "jhipster" and "okta".
+
+<%_ } else if (authenticationTypeJwt) { _%>
+
+### JWT authentication and authorization
+
+Congratulations! You've selected an excellent way to secure your NHipster application. If you're not sure what JSON Web Token (JWT) is, please see [What the Heck is JWT?](https://jwt.io/introduction/)
+
+Your app uses, to get and use the token, the `<%= nodeServerRootDir %>src/config/application.yml` settings:
+
+```yaml
+  ...
+  security:
+    authentication:
+        jwt:
+            # This token must be encoded using Base64 and be at least 512 bits long, like the HS512 key of JHipster Spring Boot (you can type `openssl rand -base64 64` on your command line to generate one)
+            base64-secret: {yourSecret}
+            # Token is valid 24 hours
+            token-validity-in-seconds: 86400
+            token-validity-in-seconds-for-remember-me: 2592000
+```
+
+You can use the default secret created from the app, or change it.
+<%_ if (generateBuiltInUserEntity) { _%>
+So to get a token, you have to pass a POST request on the _api/authenticate_ url with **UserLoginDTO** as body.
+For this you can use the client login page (if you have generated it), or a client like curl.
+<%_ } else { _%>
+This application has no users of its own: it validates the tokens issued by the application sharing this secret (like the gateway), and the user of a request is the one of its token.
+<%_ } _%>
+<%_ } else if (authenticationTypeSession) { _%>
+
+### Session authentication
+
+Like JHipster Spring Boot with HTTP sessions, the client logs in by posting the `username`, `password` and `remember-me`
+form to `api/authentication`, and logs out by posting to `api/logout`. The sessions are kept in the database of the
+application (the `<%- jhiTablePrefix %>_session` table or collection): they outlive a restart and are shared by the instances of a
+cluster. A session ends after 30 minutes without requests, 31 days with remember-me, and the account page lists the
+sessions of the user, any of which it can end. Its unsafe requests, the login included, send the token of the
+`XSRF-TOKEN` cookie as the `X-XSRF-TOKEN` header, as the JHipster clients do. The secret of the sessions is
+`jhipster.security.session.secret`, set it in production with the `JHIPSTER_SECURITY_SESSION_SECRET` environment variable.
+<%_ } _%>
+<%_ if (generateUserManagement) { _%>
+
+### Account mails
+
+Like JHipster Spring Boot, the server sends the account mails with [@nestjs-modules/mailer][] (Nodemailer): the activation mail of a registered user (who signs in once activated, with the link of the mail), the creation mail of a user created by an administrator and the password reset mail. Their HTML is the [Handlebars][] templates of `<%= nodeServerRootDir %>src/templates/mail/` (like the Thymeleaf templates of `templates/mail`; they interpolate values, escaped, and call the `message` helper of the server, they run no code), their texts the messages of `<%= nodeServerRootDir %>src/i18n/messages*.properties` in the language of the user, and their links open the client at `jhipster.mail.base-url`.
+
+The SMTP server is set by the `mail` settings of `<%= nodeServerRootDir %>src/config/application-dev.yml` and `application-prod.yml` (`localhost:25` by default), or by environment variables like `MAIL_HOST`, `MAIL_PORT`, `MAIL_USERNAME` and `MAIL_PASSWORD`. A mail that cannot be sent is logged as a warning, without failing the request.
+<%_ } _%>
+
+### Using NestJS CLI
+
+You can also use [NestJS CLI][] to generate some custom server code.
+
+For example, the following command:
+
+    nest generate module my-module
+
+will generate the file:
+
+    create <%= nodeServerRootDir %>src/my-component/my-component.module.ts
+
+
+### Building and running
+
+#### Running
+
+```bash
+<%= nodePackageManager %> run app:start
+```
+
+#### Building
+
+```bash
+<%= nodePackageManager %> run build:app
+```
+
+The build folder with all compiled sources will be **<%= nodeServerRootDir %>dist**.
+
+> For more explanation about full stack server/client build refer to [<%= nodeServerRootDir %>README.md](<%= nodeServerRootDir %>README.md)
+
+<&_ } -&>
+
+<&_ if (fragment.othersSection) { -&>
+
+### Code quality using Sonar
+
+Sonar is used to analyse code quality. You can start a local Sonar server (accessible on http://localhost:9001) with:
+
+```
+docker compose -f <%- dockerServicesDir %>sonar.yml up -d
+```
+
+Note: we have turned off forced authentication redirect for UI in [<%- dockerServicesDir %>sonar.yml](<%- dockerServicesDir %>sonar.yml) for out of the box experience while trying out SonarQube, for real use cases turn it back on.
+
+You can run a Sonar analysis with using the [sonar-scanner](https://docs.sonarqube.org/display/SCAN/Analyzing+with+SonarQube+Scanner).
+Then, run a Sonar analysis in the <%= nodeServerRootDir %> folder:
+
+```sh
+npm run sonar:scanner
+```
+
+For more information, refer to the [Code quality page][].
+
+<&_ } -&>
+
+<&_ if (fragment.referenceSection) { -&>
+[Node.js]: https://nodejs.org/
+[Vitest]: https://vitest.dev/
+[NestJS]: https://nestjs.com/
+[NestJS CLI]: https://docs.nestjs.com/cli/usages
+[@nestjs-modules/mailer]: https://nest-modules.github.io/mailer/
+[Handlebars]: https://handlebarsjs.com/
+<&_ } -&>

package/generators/node-server/templates/package.json.ejs

@@ -0,0 +1,84 @@
+<%#
+ Copyright 2019-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+{
+  "name": "<%= dasherizedBaseName %>",
+  "version": "0.0.0",
+  "description": "Description for <%= baseName %>",
+  "private": true,
+  "license": "UNLICENSED",
+  "cacheDirectories": [
+    "node_modules"
+  ],
+  "devDependencies": {
+    "@eslint/js": "<%- nodeServerDependencies['@eslint/js'] %>",
+    "concurrently": "<%= nodeDependencies['concurrently'] %>",
+    "eslint": "<%- nodeServerDependencies['eslint'] %>",
+    "eslint-config-prettier": "<%- nodeServerDependencies['eslint-config-prettier'] %>",
+    "globals": "<%- nodeServerDependencies['globals'] %>",
+    "prettier": "<%= nodeDependencies['prettier'] %>",
+    "prettier-plugin-packagejson": "<%= nodeDependencies['prettier-plugin-packagejson'] %>",
+    "typescript-eslint": "<%- nodeServerDependencies['typescript-eslint'] %>"<% if (clientFrameworkAny) { %>,
+    "wait-on": "<%= nodeDependencies['wait-on'] %>"<% } %>
+  },
+  "engines": {
+    "node": ">=<%= nodeVersion %>"
+  },
+<%_ if (clientFrameworkAny) { _%>
+  "config": {
+    "backend_port": <%= serverPort %>
+  },
+<%_ } _%>
+  "workspaces": [
+      "server"
+  ],
+  "scripts": {
+    "backend:start": "<%= clientPackageManager %> run start:server",
+<%_ if (clientFrameworkAny) { _%>
+    "app:start": "<%= clientPackageManager %> run build && BACKEND_ENV=dev <%= clientPackageManager %> run start:prod -w server",
+    "ci:e2e:package": "<%= clientPackageManager %> run build",
+<%_ if ((testFrameworks ?? []).some(testFramework => ['cypress', 'playwright'].includes(testFramework))) { _%>
+    "e2e": "<%= clientPackageManager %> run e2e -w client",
+<%_ } _%>
+    "ci:e2e:server:start": "BACKEND_ENV=test <%= clientPackageManager %> run start:prod -w server",
+    "build": "<%= clientPackageManager %> run build -w server && <%= clientPackageManager %> run build -w client",
+<%_ } else { _%>
+    "build": "<%= clientPackageManager %> run build -w server",
+<%_ } _%>
+    "build:app": "<%= clientPackageManager %> run build -w server",
+    "ci:docker:build": "<%= clientPackageManager %> run docker:build",
+    "docker:build": "docker build -t <%= baseName.toLowerCase() %> .",
+    "lint": "<%= clientPackageManager %> run lint --workspaces",
+    "lint:fix": "<%= clientPackageManager %> run lint:fix --workspaces",
+    "prettier:check": "prettier --check \"{,src/**/}*.{<%= prettierExtensions %>}\"",
+    "prettier:format": "prettier --write \"{,src/**/}*.{<%= prettierExtensions %>}\"",
+<%_ if (clientFrameworkAny) { _%>
+    "start": "concurrently -k -s first -n application,client -c red,green npm:start:server npm:start:client",
+<%_ } else { _%>
+    "start": "<%= clientPackageManager %> run start:server",
+<%_ } _%>
+    "start:server": "<%= clientPackageManager %> run start -w server",
+<%_ if (clientFrameworkAny) { _%>
+    "start:client": "<%= clientPackageManager %> run start -w client",
+    "test:client": "<%= clientPackageManager %> test -w client",
+<%_ } _%>
+    "test:server": "<%= clientPackageManager %> test -w server",
+    "test:server:e2e": "<%= clientPackageManager %> run test:e2e -w server",
+    "test": "<%= clientPackageManager %> test --workspaces"
+  }
+}