Installation

Install the packages you need and register two modules: one provider block for Angular, one module import for NestJS.

Prerequisites

The packages are published for current Node.js releases and npm 10 or newer. Check what you have before installing.

# Node.js ^22.12 or >= 26, npm >= 10
node --version
npm --version

On the consumer side the Angular packages target Angular 22 and the backend packages target NestJS 11.

Where to install

A new workspace

If you are starting from nothing, the smart:scaffold-nx-workspace skill from the smart@smartsoft Claude Code plugin generates an Nx workspace that already follows the conventions these docs assume, and is documented in the Skills section (coming soon).

An existing workspace

In an existing Angular or NestJS project nothing needs to be restructured. Install the packages into the project that uses them and continue with the wiring below.

Something to compare against

The example application is a complete Angular and NestJS pair on the framework, kept in the repository and tested on every pull request. When a step on this page raises a question, it shows the answer in running code.

Create a project

The commands on this page are the ones the smoke test runs, and it starts from an empty npm project.

mkdir my-app && cd my-app
npm init -y

What to install

Each package is published on its own, but a project rarely wants one of them. Four packages group the rest by what a project actually is, and pin one version of each library they bring, so the whole set stays consistent.

The split follows what a project runs on rather than where the code sits, so a frontend written in something other than Angular gets its own stack later without core or any existing package changing name.

Installing a single library still works and is the right choice when a project needs exactly one, for example only the validators from utils. Every package page shows its own install command.

Frontend and backend

A project with both halves installs the whole framework with one command:

npm install @smartsoft001/full-stack

That brings core and both runtime stacks at one version. The two sections below then apply to each half; nothing else is needed. Payments stay a separate opt-in, described under NestJS.

Angular

One command installs everything an Angular application uses: the UI components, the CRUD screens and the framework-agnostic core they are built on.

npm install @smartsoft001/angular-stack

Then register the shared providers in the application config.

import { provideHttpClient } from '@angular/common/http';
import { ApplicationConfig, importProvidersFrom } from '@angular/core';
import { provideRouter } from '@angular/router';
import { provideTranslateService } from '@ngx-translate/core';

import { SharedModule } from '@smartsoft001/angular';

export const appConfig: ApplicationConfig = {
  providers: [
    provideRouter([]),
    provideHttpClient(),
    provideTranslateService(),
    importProvidersFrom(SharedModule),
  ],
};

Each entry earns its place. provideRouter is required because the framework's page components navigate between list and item routes. provideHttpClient backs the services that talk to the backend. provideTranslateService is not optional: SharedModule injects TranslateService in its constructor to install the default translations and language, so the application fails to start without it. importProvidersFrom(SharedModule) pulls in the module itself, which exports the shared factories, services, pipes, pages and directives that the UI components rely on.

With that in place a component can use the framework's elements directly, as the smart-button sample on the home page shows.

NestJS

One command installs the server side: the shared module, MongoDB access, the CRUD and auth shells, and the same core.

npm install @smartsoft001/nestjs-stack

Then configure the shared module once, in the application module.

import { Module } from '@nestjs/common';

import { SharedModule } from '@smartsoft001/nestjs';

@Module({
  imports: [
    SharedModule.forRoot({
      tokenConfig: {
        secretOrPrivateKey: 'change-me',
        expiredIn: 3600,
      },
      permissions: {
        create: ['admin'],
        read: ['admin', 'user'],
        update: ['admin'],
        delete: ['admin'],
      },
      db: {
        host: 'localhost',
        port: 27017,
        database: 'my-app',
      },
    }),
  ],
})
export class AppModule {}

SharedModule.forRoot takes three pieces of configuration. tokenConfig holds the JWT signing key and the token lifetime in seconds, and it feeds the JWT strategy that guards the endpoints, so the placeholder above must be replaced by a real secret from your environment. permissions maps each operation, create, read, update and delete, to the list of roles allowed to perform it, and the permission service checks the user's roles against that map. db is the MongoDB connection the repositories use. Use forRoot in the application module and forFeature in a feature module that should reuse the same configuration without opening a second database connection.

Payments

A service that takes payments adds the transaction family and the provider integrations.

npm install @smartsoft001/payments-stack

Keeping it up to date

The packages are released together, so a project moves the whole set at once and the release brings its own migrations with it. Upgrading has the two commands.

Verify

There is nothing to take on trust here. The commands above are not transcribed into this page: they are regions of the installation script that the repository's continuous integration executes against the packages published on npm before every deploy of these docs. The script installs every published @smartsoft001/* package into a throwaway project and resolves the entry points, so if an install command stopped working the docs would not ship.

Where next

• Example application is the smallest application that uses the framework end to end, with the commands to run it.
• Architecture follows one entity from its decorators to a generated screen.
• Introduction lists the packages and how they are layered.