@aurorajs.dev/catalyst-cli 1.0.0

package/dist/templates/backend/application/src/@aurora/shared.module.ts

@@ -0,0 +1,51 @@
+import {
+  AuditingRunner,
+  AuditingRunnerDisabledImplementationService,
+  CoreAddI18nConstraintService,
+  CoreGetContentLanguageObjectService,
+  CoreGetFallbackLangService,
+  CoreGetLangsService,
+  CoreGetSearchKeyLangService,
+} from '@aurorajs.dev/core-back';
+import { CacheModule } from '@nestjs/cache-manager';
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+import { CoreGetFallbackLangFromJsonService, CoreGetLangsFromJsonService } from './modules';
+
+@Module({
+  imports: [
+    CacheModule.register({ isGlobal: true, ttl: 0 }),
+    ConfigModule.forRoot({
+      isGlobal: true,
+      envFilePath: ['.env'],
+    }),
+    EventEmitterModule.forRoot()
+  ],
+  providers: [
+    CoreAddI18nConstraintService,
+    CoreGetContentLanguageObjectService,
+    CoreGetSearchKeyLangService,
+    {
+      provide: AuditingRunner,
+      useClass: AuditingRunnerDisabledImplementationService,
+    },
+    {
+      provide: CoreGetFallbackLangService,
+      useClass: CoreGetFallbackLangFromJsonService,
+    },
+    {
+      provide: CoreGetLangsService,
+      useClass: CoreGetLangsFromJsonService,
+    },
+  ],
+  exports: [
+    AuditingRunner,
+    CoreAddI18nConstraintService,
+    CoreGetContentLanguageObjectService,
+    CoreGetFallbackLangService,
+    CoreGetLangsService,
+    CoreGetSearchKeyLangService
+  ],
+})
+export class SharedModule {}

package/dist/templates/backend/application/src/@bridges/bridges.module.ts

@@ -0,0 +1,27 @@
+import { Global, Module } from '@nestjs/common';
+
+/**
+ * Composition root for cross-bounded-context dependencies (zero-leak variant).
+ *
+ * Imports the supplier modules where the cross-BC adapters live (registered in their
+ * own @app/<supplier-bc>/<module>/cross-bc/ folders and exported from each supplier module).
+ * Registers ONLY the bridge entries — the provider mappings that bind port tokens to the
+ * adapter instances via `useExisting`. The adapters themselves are NOT providers of this
+ * module; they are imported transitively through the supplier modules.
+ *
+ * Consumers inject ports via `@Inject(<TOKEN>)` without their own NestJS module importing
+ * the supplier module — this stays true under the zero-leak variant.
+ *
+ * See `.claude/skills/catalyst-cross-bounded-context-ports/SKILL.md` for the full pattern,
+ * including the "Alternative pattern: zero-leak" section that documents the trade-offs
+ * vs. the canonical (curated-export) variant.
+ */
+@Global()
+@Module({
+  imports: [],
+  providers: [
+],
+  exports: [
+],
+})
+export class BridgesModule {}

package/dist/templates/backend/application/src/@config/index.ts

@@ -0,0 +1 @@
+export * from './mailer';

package/dist/templates/backend/application/src/@config/mailer/index.ts

@@ -0,0 +1 @@
+export * from './mailer-transport.module';

package/dist/templates/backend/application/src/@config/mailer/mailer-transport.module.ts

@@ -0,0 +1,16 @@
+import { MailerSMTPTransportService } from '@aurora/modules/mailer/mailer-smtp-transport.service';
+import { MailerTransportService } from '@aurorajs.dev/core-back';
+import { HttpModule } from '@nestjs/axios';
+import { Module } from '@nestjs/common';
+
+@Module({
+  imports: [HttpModule],
+  providers: [
+    {
+      provide: MailerTransportService,
+      useClass: MailerSMTPTransportService,
+    },
+  ],
+  exports: [MailerTransportService],
+})
+export class MailerTransportModule {}

package/dist/templates/backend/application/src/app.controller.spec.ts

@@ -0,0 +1,22 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+describe('AppController', () => {
+  let appController: AppController;
+
+  beforeEach(async () => {
+    const app: TestingModule = await Test.createTestingModule({
+      controllers: [AppController],
+      providers: [AppService],
+    }).compile();
+
+    appController = app.get<AppController>(AppController);
+  });
+
+  describe('root', () => {
+    it('should return "Hello World!"', () => {
+      expect(appController.getHello()).toBe('Hello World!');
+    });
+  });
+});

package/dist/templates/backend/application/src/app.controller.ts

@@ -0,0 +1,12 @@
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}

package/dist/templates/backend/application/src/app.module.ts

@@ -0,0 +1,17 @@
+import { CoreModule } from '@aurora/core.module';
+import { AuthenticationModule } from '@aurora/modules/authentication';
+import { BridgesModule } from '@bridges/bridges.module';
+import { Module } from '@nestjs/common';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [
+    CoreModule,
+    AuthenticationModule,
+    BridgesModule
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}

package/dist/templates/backend/application/src/app.service.ts

@@ -0,0 +1,8 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}

package/dist/templates/backend/application/src/i18n/en/iam.json

@@ -0,0 +1,18 @@
+{
+    "PasswordRecovery": "Password Recovery",
+    "ForgotPasswordEmailTemplate": {
+        "Phrase1": "We received a request to recover the password for user {username} with email {email}",
+        "Phrase2": "Reset your password by clicking the button below:",
+        "Phrase3": "Reset Password",
+        "Phrase4": "Or open the following link:",
+        "Phrase5": "The reset password link / button will expire in {validHours} hour/s.",
+        "Phrase6": "If you didn't request a password recovery you can disregard this email."
+    },
+    "error": {
+        "uniqueEmail": "Email {email} already in use",
+        "uniqueUsername": "Username {username} already in use",
+        "uniqueCode": "Code {code} already in use",
+        "insufficientPermissions": "Insufficient permissions to assign these roles",
+        "userBlockRequired": "User block is required for accounts of type USER"
+    }
+}

package/dist/templates/backend/application/src/i18n/es/iam.json

@@ -0,0 +1,18 @@
+{
+    "PasswordRecovery": "Recuperación de contraseña",
+    "ForgotPasswordEmailTemplate": {
+        "Phrase1": "Hemos recibido una solicitud para recuperar la contraseña del usuario {username} con email {email}",
+        "Phrase2": "Restablece tu contraseña haciendo clic en el botón de abajo:",
+        "Phrase3": "Restablecer contraseña",
+        "Phrase4": "O abra el siguiente enlace:",
+        "Phrase5": "El enlace / botón para restablecer la contraseña caducará en {validHours} hora/s.",
+        "Phrase6": "Si no has solicitado la recuperación de la contraseña, puedes ignorar este correo electrónico."
+    },
+    "error": {
+        "uniqueEmail": "El email {email} ya está en uso",
+        "uniqueUsername": "El nombre de usuario {username} ya está en uso",
+        "uniqueCode": "El código {code} ya está en uso",
+        "insufficientPermissions": "No tiene permisos suficientes para asignar estos roles",
+        "userBlockRequired": "El bloque de usuario es obligatorio para cuentas de tipo USER"
+    }
+}

package/dist/templates/backend/application/src/main.ts

@@ -0,0 +1,113 @@
+import { System, setTimeZoneApplication } from '@aurorajs.dev/core-back';
+import { ConfigService } from '@nestjs/config';
+import { NestFactory } from '@nestjs/core';
+import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';
+import dayjs from 'dayjs';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import dayOfYear from 'dayjs/plugin/dayOfYear';
+import isoWeek from 'dayjs/plugin/isoWeek';
+import timezone from 'dayjs/plugin/timezone';
+import utc from 'dayjs/plugin/utc';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+import { json, urlencoded } from 'express';
+import { env } from 'node:process';
+import { logger } from './@aurora/services';
+import { AppModule } from './app.module';
+
+// dayjs configuration
+dayjs.extend(utc);
+dayjs.extend(timezone);
+dayjs.extend(advancedFormat);
+dayjs.extend(weekOfYear);
+dayjs.extend(isoWeek);
+dayjs.extend(dayOfYear);
+
+async function bootstrap(): Promise<void> {
+  const app = await NestFactory.create(AppModule, { logger: logger() });
+  const configService = app.get(ConfigService);
+
+  if (configService.get<string>('SWAGGER') === 'true') {
+    const options = new DocumentBuilder()
+      .setTitle('Aurora API')
+      .setDescription('Aurora API description')
+      .setVersion('1.0')
+      .addBearerAuth()
+      .build();
+    const document = SwaggerModule.createDocument(app, options);
+    SwaggerModule.setup('api', app, document);
+  }
+
+  // set limit of request allowed
+  app.use(json({ limit: configService.get<string>('APP_LIMIT_REQUEST_SIZE') }));
+  app.use(
+    urlencoded({
+      extended: true,
+      limit: configService.get<string>('APP_LIMIT_REQUEST_SIZE'),
+    }),
+  );
+
+  // set graphql upload files, workaround for import graphql-upload
+  const { default: graphqlUploadExpress } = await (eval(
+    "import('graphql-upload/graphqlUploadExpress.mjs')",
+  ) as Promise<typeof import('graphql-upload/graphqlUploadExpress.mjs')>);
+  app.use(
+    '/graphql',
+    graphqlUploadExpress({
+      maxFileSize: +configService.get<string>('APP_MAX_FILE_SIZE_UPLOADED'), // 50000000 = 50 MB, value in bytes
+      maxFiles: configService.get<string>('APP_MAX_FILES_UPLOADED'), // max files uploaded at once
+    }),
+  );
+
+  // Trust Proxy — env-driven, default DISABLED (safe for direct-connect; prevents
+  // X-Forwarded-For spoofing when there is no reverse proxy in front of the server).
+  // Set TRUST_PROXY to enable: use a numeric hop count (1, 2, …) or the literal
+  // "true" (trust all) / "false" (explicit disable). Required for correct per-IP
+  // throttling and OAuthCredential.ipAddress when running behind nginx / ALB / Cloud Run.
+  const trustProxy = configService.get<string>('TRUST_PROXY');
+  if (trustProxy !== undefined && trustProxy !== '') {
+    // app.set() is Express-specific — access via the underlying HTTP adapter instance.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    const expressApp = app.getHttpAdapter().getInstance() as {
+      set: (key: string, value: unknown) => void;
+    };
+    const numericValue = Number(trustProxy);
+    if (trustProxy === 'true') {
+      expressApp.set('trust proxy', true);
+    } else if (trustProxy === 'false') {
+      expressApp.set('trust proxy', false);
+    } else if (Number.isFinite(numericValue)) {
+      expressApp.set('trust proxy', numericValue);
+    }
+    // Unrecognised values are silently ignored — default (disabled) is preserved.
+  }
+
+  // set timezone application from .env APP_TIMEZONE on dayjs
+  setTimeZoneApplication(configService, dayjs);
+
+  app.setGlobalPrefix('api', {
+    exclude: ['graphql', '.well-known/jwks.json'],
+  });
+
+  // CORS. When APP_CORS_ORIGIN is set (comma-separated allowlist), enable credentialed CORS so the
+  // Authorization Code continue-flow works cross-origin: the hub frontend POSTs the access token
+  // to POST /api/o-auth/session with `withCredentials` and the backend must accept it and set the
+  // `hub_session` cookie. A credentialed response cannot use a wildcard origin, so the allowlist is
+  // explicit. With APP_CORS_ORIGIN unset, fall back to the previous open (credential-less) behavior.
+  const corsOrigin = configService.get<string>('APP_CORS_ORIGIN');
+  if (corsOrigin) {
+    app.enableCors({
+      origin: corsOrigin.split(',').map((origin) => origin.trim()),
+      credentials: true,
+    });
+  } else {
+    app.enableCors();
+  }
+
+  await app.listen(configService.get<number>('APP_PORT') ?? 3000);
+
+  if (env.NODE_ENV !== 'production') {
+    System.memoryWatcher();
+  }
+}
+
+bootstrap();

package/dist/templates/backend/application/src/repl.ts

@@ -0,0 +1,8 @@
+import { repl } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap(): Promise<void> {
+  await repl(AppModule);
+}
+
+bootstrap();

package/dist/templates/backend/application/test/app.e2e-spec.ts

@@ -0,0 +1,22 @@
+import { INestApplication } from '@nestjs/common';
+import { Test, TestingModule } from '@nestjs/testing';
+import request from 'supertest';
+import { App } from 'supertest/types';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer()).get('/').expect(200).expect('Hello World!');
+  });
+});

package/dist/templates/backend/application/test/authentication-none-mode.e2e-spec.ts

@@ -0,0 +1,138 @@
+/**
+ * e2e: authentication none-mode boot test.
+ *
+ * Verifies:
+ * - App boots with OAUTH_STRATEGY=none and NO .keys/ directory (no key file read).
+ * - An endpoint with no declared permissions is reachable and returns 200 with an anonymous user.
+ * - An endpoint protected with @Auth('x') returns 403 (anonymous account has dPermissions.all=[]).
+ *
+ * Uses a minimal NestJS application (no database, no Sequelize, no full AppModule) so the test
+ * is isolated and fast. The AuroraHubConsumerAdapter is mocked to avoid the jwks-rsa ESM issue.
+ */
+
+// Mock ESM-importing module BEFORE imports
+jest.mock(
+  '../src/@aurora/modules/authentication/infrastructure/strategies/aurora-hub/aurora-hub-consumer.adapter',
+  () => ({
+    AuroraHubConsumerAdapter: class AuroraHubConsumerAdapterMock {
+      getPassportOptions() {
+        return { jwtFromRequest: () => null, secretOrKey: 'mock' };
+      }
+      validate(): Promise<Record<string, never>> {
+        return Promise.resolve({});
+      }
+    },
+  }),
+);
+
+import { CacheModule } from '@nestjs/cache-manager';
+import { Controller, Get, INestApplication, Module, SetMetadata, UseGuards } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { Reflector } from '@nestjs/core';
+import { PassportModule } from '@nestjs/passport';
+import { Test } from '@nestjs/testing';
+import request from 'supertest';
+import { App } from 'supertest/types';
+import { AuthenticationModule } from '../src/@aurora/modules/authentication/authentication.module';
+import { ACCOUNT_LOADER } from '../src/@aurora/modules/authentication/domain/ports';
+import {
+  AuthenticationJwtGuard,
+  AuthorizationPermissionsGuard,
+} from '../src/@aurora/modules/authentication/infrastructure/guards';
+import { LocalProviderAdapter } from '../src/@aurora/modules/authentication/infrastructure/strategies/local-provider/local-provider.adapter';
+
+// ---------------------------------------------------------------------------
+// Minimal test controllers
+// ---------------------------------------------------------------------------
+
+/** Public endpoint — no permissions declared. Should return 200 with anonymous user. */
+@Controller()
+class TestPublicController {
+  @Get('public')
+  getPublic(): { ok: boolean; username: string } {
+    // In real production code the account would be injected via @CurrentAccount().
+    // For this test we return a simple OK since we verify the HTTP status code.
+    return { ok: true, username: 'anonymous' };
+  }
+}
+
+/** Protected endpoint — @Auth-style guard applied. Should return 403 for anonymous user.
+ *  @Auth is a ClassDecorator: it sets permissions metadata on the CLASS (not the method),
+ *  which is how AuthorizationPermissionsGuard reads it via `context.getClass()`.
+ */
+@SetMetadata('permissions', ['test.protected.permission'])
+@UseGuards(AuthenticationJwtGuard, AuthorizationPermissionsGuard)
+@Controller()
+class TestProtectedController {
+  @Get('protected')
+  getProtected(): { ok: boolean } {
+    return { ok: true };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Minimal test module
+// ---------------------------------------------------------------------------
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({ isGlobal: true }),
+    CacheModule.register({ isGlobal: true }),
+    PassportModule.register({ defaultStrategy: 'jwt' }),
+    AuthenticationModule,
+  ],
+  controllers: [TestPublicController, TestProtectedController],
+  providers: [Reflector, { provide: ACCOUNT_LOADER, useValue: { loadById: jest.fn() } }],
+})
+class TestAppModule {}
+
+// ---------------------------------------------------------------------------
+// e2e tests
+// ---------------------------------------------------------------------------
+
+describe('Authentication none-mode (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeAll(async () => {
+    // Ensure no OAUTH_STRATEGY key files are needed
+    process.env.OAUTH_STRATEGY = 'none';
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [TestAppModule],
+    })
+      .overrideProvider(ACCOUNT_LOADER)
+      .useValue({ loadById: jest.fn() })
+      // Override LocalProviderAdapter to avoid CACHE_MANAGER DI in test context
+      .overrideProvider(LocalProviderAdapter)
+      .useValue({
+        getPassportOptions: () => ({ jwtFromRequest: () => null, secretOrKey: 'mock' }),
+        validate: jest.fn(),
+      })
+      .compile();
+
+    app = moduleRef.createNestApplication();
+    await app.init();
+  });
+
+  afterAll(async () => {
+    delete process.env.OAUTH_STRATEGY;
+    await app.close();
+  });
+
+  it('boots successfully with OAUTH_STRATEGY=none and no key files', () => {
+    // If we reach this point, the app booted — that is the assertion.
+    expect(app).toBeDefined();
+  });
+
+  it('GET /public returns 200 (unprotected endpoint reachable anonymously)', async () => {
+    await request(app.getHttpServer()).get('/public').expect(200);
+  });
+
+  it('GET /protected returns 401 with statusCode:403 in body (anonymous has no permissions)', async () => {
+    // AuthorizationPermissionsGuard throws UnauthorizedException (HTTP 401) with body statusCode:403.
+    // The HTTP status is 401 because NestJS maps UnauthorizedException → 401.
+    // The body carries statusCode:403 to signal permission denial vs. missing authentication.
+    const res = await request(app.getHttpServer()).get('/protected').expect(401);
+    expect(res.body.statusCode).toBe(403);
+  });
+});

package/dist/templates/backend/application/test/jest-e2e.json

@@ -0,0 +1,18 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": "..",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  },
+  "moduleNameMapper": {
+    "^uuid$": "<rootDir>/test/mocks/uuid.mock.ts",
+    "^mime$": "<rootDir>/test/mocks/mime.mock.ts",
+    "@api/(.*)": "<rootDir>/src/@api/$1",
+    "@app/(.*)": "<rootDir>/src/@app/$1",
+    "@aurora/(.*)": "<rootDir>/src/@aurora/$1",
+    "@bridges/(.*)": "<rootDir>/src/@bridges/$1",
+    "@config/(.*)": "<rootDir>/src/@config/$1"
+  }
+}

package/dist/templates/backend/application/test/mocks/mime.mock.ts

@@ -0,0 +1,10 @@
+const mime = {
+  getType: (_path: string): string | null => null,
+  getExtension: (_type: string): string | null => null,
+  define: (_typeMap: Record<string, string[]>): void => undefined,
+};
+
+export default mime;
+export const getType = mime.getType;
+export const getExtension = mime.getExtension;
+export const define = mime.define;

package/dist/templates/backend/application/test/mocks/uuid.mock.ts

@@ -0,0 +1,17 @@
+let counter = 0;
+
+const next = (): string => '00000000-0000-0000-0000-' + String(++counter).padStart(12, '0');
+
+export const v1 = next;
+export const v3 = next;
+export const v4 = next;
+export const v5 = next;
+export const v6 = next;
+export const v7 = next;
+export const NIL = '00000000-0000-0000-0000-000000000000';
+export const validate = (value: string): boolean => /^[0-9a-f-]{36}$/i.test(value);
+export const version = (): number => 4;
+export const parse = (value: string): Uint8Array => new Uint8Array(16);
+export const stringify = (): string => next();
+
+export default { v1, v3, v4, v5, v6, v7, NIL, validate, version, parse, stringify };

package/dist/templates/backend/application/tsconfig.build.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": [
+    "node_modules",
+    "test",
+    "dist",
+    "**/*spec.ts",
+    "scripts"
+  ]
+}

package/dist/templates/backend/application/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "baseUrl": "./",
+    "declaration": true,
+    "emitDecoratorMetadata": true,
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "forceConsistentCasingInFileNames": false,
+    "incremental": true,
+    "isolatedModules": false,
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "noFallthroughCasesInSwitch": false,
+    "noImplicitAny": false,
+    "outDir": "./dist",
+    "paths": {
+      "@api/*": [
+        "src/@api/*"
+      ],
+      "@app/*": [
+        "src/@app/*"
+      ],
+      "@aurora/*": [
+        "src/@aurora/*"
+      ],
+      "@bridges/*": [
+        "src/@bridges/*"
+      ],
+      "@config/*": [
+        "src/@config/*"
+      ]
+    },
+    "removeComments": false,
+    "resolvePackageJsonExports": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": false,
+    "strictNullChecks": false,
+    "strictPropertyInitialization": false,
+    "target": "ES2023",
+    "useDefineForClassFields": false
+  }
+}

package/dist/templates/backend/env/.env

@@ -0,0 +1,77 @@
+# node
+NODE_ENV = development
+
+# app
+APP_NAME = Aurora
+APP_URL = http://localhost:8080
+APP_FRONTEND_URL = http://localhost:4200
+APP_PORT = 8080
+APP_LIMIT_REQUEST_SIZE = 50mb
+APP_SSR = false
+APP_FALLBACK_LANG = es
+# options: id | iso6392 | iso6393 | ietf
+APP_SEARCH_KEY_LANG = iso6392
+APP_CORS_ORIGIN = *
+
+# https://github.com/zeit/ms
+APP_ACCESS_TOKEN_EXPIRE = 10m
+APP_REFRESH_TOKEN_EXPIRE = 30m
+
+# server timezone
+APP_TIMEZONE = UTC
+
+# upload files
+APP_MAX_FILE_SIZE_UPLOADED = 50000000
+APP_MAX_FILES_UPLOADED = 10
+
+# app health
+APP_HEALTH_SECONDS_MEMORY_CHECK = 300
+
+# logger
+LOGGER_ERROR_LOG_PATH = logs/aurora-error.log
+LOGGER_CONSOLE_LOG_PATH = logs/aurora-console.log
+
+# graphql
+GRAPHQL_DEBUG = true
+GRAPHQL_PLAYGROUND = true
+GRAPHQL_CREATE_DEFINITIONS = true
+GRAPHQL_TYPE_PATH = src/@api/graphql.ts
+
+# swagger
+SWAGGER = true
+
+# mailer
+MAILER_ENABLED = false
+MAILER_HOST = smtp.contoso.com
+MAILER_PORT = 465
+MAILER_IGNORE_TLS = false
+MAILER_SECURE = false
+MAILER_USER = no-reply@contoso.com
+MAILER_PASSWORD =
+MAILER_FROM = '"CONTOSO" <no-reply@contoso.com>'
+
+# database
+DATABASE_DIALECT = postgres
+DATABASE_STORAGE =
+DATABASE_HOST = localhost
+DATABASE_SOCKET = ""
+DATABASE_PORT = 5432
+DATABASE_USER = postgres
+DATABASE_PASSWORD = postgres
+DATABASE_SCHEMA =
+DATABASE_SYNCHRONIZE = false
+DATABASE_SYNCHRONIZE_ALTER = false
+DATABASE_LOGGIN = false
+
+# storage account
+STORAGE_ACCOUNT_URL = http://localhost:8080
+STORAGE_ACCOUNT_PUBLIC_PATH = public
+
+# oauth
+OAUTH_PRIVATE_KEY_PATH = .keys/oauth-private.key
+OAUTH_PUBLIC_KEY_PATH = .keys/oauth-public.key
+OAUTH_STRATEGY = none # options: none | aurora-hub | local-provider
+OAUTH_APPLICATION_CODE = aurora
+OAUTH_APPLICATION_SECRET = xxxxxxxxxxxxxxxxxxxx
+OAUTH_REDIRECT_URI = http://localhost:4201/callback
+OAUTH_HUB_SERVER_URL = http://localhost:8080