@simple-auth-kit/cli 1.0.0

package/registry/combos/nestjs-prisma/variants/base/src/country.repository.ts

@@ -0,0 +1,149 @@
+import { ConflictException, Inject, Injectable, NotFoundException } from "@nestjs/common";
+import { Prisma, PrismaClient } from "../generated/prisma/client.js";
+import { toId, toIdOrNull } from "./id.helper.js";
+import { buildPageMeta, normalizeLimit, normalizePage, type Paginated } from "./pagination.js";
+
+/** A `Country` row as `findUnique`/`findMany` return it. */
+export type CountryRow = Prisma.CountryGetPayload<object>;
+
+/**
+ * Every column the `Country` table has — there is no secret to withhold here, unlike `User`.
+ * Deliberately not a hand-picked subset, same reasoning as `toUserSummary`.
+ */
+export interface CountrySummary {
+  id: string;
+  uuid: string;
+  code: string;
+  name: string;
+  emoji: string;
+  phoneCode: string;
+  currency: string;
+  currencyName: string;
+  isoCode: string;
+  flag: string | null;
+  isActive: boolean;
+  createdBy: string | null;
+  updatedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export function toCountrySummary(row: CountryRow): CountrySummary {
+  return {
+    id: row.id.toString(),
+    uuid: row.uuid,
+    code: row.code,
+    name: row.name,
+    emoji: row.emoji,
+    phoneCode: row.phoneCode,
+    currency: row.currency,
+    currencyName: row.currencyName,
+    isoCode: row.isoCode,
+    flag: row.flag,
+    isActive: row.isActive,
+    createdBy: row.createdBy?.toString() ?? null,
+    updatedBy: row.updatedBy?.toString() ?? null,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+export interface CountryListFilter {
+  search?: string;
+  page?: number;
+  limit?: number;
+  activeOnly?: boolean;
+}
+
+export type CountryListResult = Paginated<CountrySummary>;
+
+export interface CountryInput {
+  code: string;
+  name: string;
+  emoji: string;
+  phoneCode: string;
+  currency: string;
+  currencyName: string;
+  isoCode: string;
+  flag?: string | null;
+  isActive?: boolean;
+}
+
+@Injectable()
+export class CountryRepository {
+  constructor(@Inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  /** Newest-first, page-paginated; `search` matches name/code/isoCode. Returns raw rows — shaping is the caller's job. */
+  async list(filter: CountryListFilter = {}): Promise<CountryListResult> {
+    const page = normalizePage(filter.page);
+    const limit = normalizeLimit(filter.limit);
+    const where: Prisma.CountryWhereInput = {
+      isDeleted: false,
+      isActive: filter.activeOnly ? true : undefined,
+      OR: filter.search
+        ? [
+            { name: { contains: filter.search, mode: "insensitive" } },
+            { code: { contains: filter.search, mode: "insensitive" } },
+            { isoCode: { contains: filter.search, mode: "insensitive" } },
+          ]
+        : undefined,
+    };
+
+    const [rows, total] = await this.prisma.$transaction([
+      this.prisma.country.findMany({ where, orderBy: [{ createdAt: "desc" }, { id: "desc" }], take: limit, skip: (page - 1) * limit }),
+      this.prisma.country.count({ where }),
+    ]);
+
+    return { items: rows.map(toCountrySummary), meta: buildPageMeta(page, limit, total) };
+  }
+
+  async get(countryId: string): Promise<CountrySummary> {
+    const row = await this.prisma.country.findUnique({ where: { id: toId(countryId), isDeleted: false } });
+    if (!row) throw new NotFoundException(`country "${countryId}" not found`);
+    return toCountrySummary(row);
+  }
+
+  async create(input: CountryInput, actorUserId: string | null): Promise<CountrySummary> {
+    const existing = await this.prisma.country.findFirst({ where: { OR: [{ code: input.code }, { isoCode: input.isoCode }] } });
+    if (existing) throw new ConflictException("a country with this code or ISO code already exists");
+
+    const row = await this.prisma.country.create({
+      data: { ...input, createdBy: toIdOrNull(actorUserId), updatedBy: toIdOrNull(actorUserId) },
+    });
+    return toCountrySummary(row);
+  }
+
+  async update(countryId: string, input: Partial<CountryInput>, actorUserId: string | null): Promise<CountrySummary> {
+    const countryIdBig = toId(countryId);
+    const existing = await this.prisma.country.findUnique({ where: { id: countryIdBig, isDeleted: false }, select: { id: true } });
+    if (!existing) throw new NotFoundException(`country "${countryId}" not found`);
+
+    if (input.code !== undefined || input.isoCode !== undefined) {
+      const clash = await this.prisma.country.findFirst({
+        where: { NOT: { id: countryIdBig }, OR: [{ code: input.code }, { isoCode: input.isoCode }] },
+      });
+      if (clash) throw new ConflictException("a country with this code or ISO code already exists");
+    }
+
+    const row = await this.prisma.country.update({ where: { id: countryIdBig }, data: { ...input, updatedBy: toIdOrNull(actorUserId) } });
+    return toCountrySummary(row);
+  }
+
+  // Soft-delete, matching every other table's isDeleted/deletedAt/deletedBy/deletedReason pattern.
+  async delete(countryId: string, actorUserId: string | null, reason?: string): Promise<void> {
+    const countryIdBig = toId(countryId);
+    const existing = await this.prisma.country.findUnique({ where: { id: countryIdBig, isDeleted: false }, select: { id: true } });
+    if (!existing) throw new NotFoundException(`country "${countryId}" not found`);
+    await this.prisma.country.update({
+      where: { id: countryIdBig },
+      data: { isDeleted: true, deletedAt: new Date(), deletedBy: toIdOrNull(actorUserId), deletedReason: reason ?? null },
+    });
+  }
+
+  async setActive(countryId: string, isActive: boolean, actorUserId: string | null): Promise<void> {
+    const countryIdBig = toId(countryId);
+    const existing = await this.prisma.country.findUnique({ where: { id: countryIdBig, isDeleted: false }, select: { id: true } });
+    if (!existing) throw new NotFoundException(`country "${countryId}" not found`);
+    await this.prisma.country.update({ where: { id: countryIdBig }, data: { isActive, updatedBy: toIdOrNull(actorUserId) } });
+  }
+}

package/registry/combos/nestjs-prisma/variants/base/src/customer.repository.ts

@@ -0,0 +1,169 @@
+import { ConflictException, Inject, Injectable, NotFoundException } from "@nestjs/common";
+import { Prisma, PrismaClient } from "../generated/prisma/client.js";
+import { toId, toIdOrNull } from "./id.helper.js";
+import { buildPageMeta, normalizeLimit, normalizePage, type Paginated } from "./pagination.js";
+
+/** A `Customer` row as `findUnique`/`findMany` return it. */
+export type CustomerRow = Prisma.CustomerGetPayload<object>;
+
+/**
+ * Every column the `Customer` table has — no login credential exists to withhold, unlike `User`.
+ * Deliberately not a hand-picked subset, same reasoning as `toUserSummary`.
+ */
+export interface CustomerSummary {
+  id: string;
+  uuid: string;
+  firstName: string | null;
+  lastName: string | null;
+  username: string | null;
+  email: string;
+  phone: string | null;
+  dob: string | null;
+  gender: string | null;
+  joinedDate: string;
+  photo: string | null;
+  isEmailVerified: boolean;
+  isPhoneVerified: boolean;
+  isActive: boolean;
+  createdBy: string | null;
+  updatedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export function toCustomerSummary(row: CustomerRow): CustomerSummary {
+  return {
+    id: row.id.toString(),
+    uuid: row.uuid,
+    firstName: row.firstName,
+    lastName: row.lastName,
+    username: row.username,
+    email: row.email,
+    phone: row.phone,
+    dob: row.dob?.toISOString() ?? null,
+    gender: row.gender,
+    joinedDate: row.joinedDate.toISOString(),
+    photo: row.photo,
+    isEmailVerified: row.isEmailVerified,
+    isPhoneVerified: row.isPhoneVerified,
+    isActive: row.isActive,
+    createdBy: row.createdBy?.toString() ?? null,
+    updatedBy: row.updatedBy?.toString() ?? null,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+export interface CustomerListFilter {
+  search?: string;
+  page?: number;
+  limit?: number;
+  activeOnly?: boolean;
+}
+
+export type CustomerListResult = Paginated<CustomerSummary>;
+
+export interface CustomerInput {
+  email: string;
+  firstName?: string | null;
+  lastName?: string | null;
+  username?: string | null;
+  phone?: string | null;
+  dob?: string | null;
+  gender?: string | null;
+  joinedDate?: string;
+  photo?: string | null;
+  isEmailVerified?: boolean;
+  isPhoneVerified?: boolean;
+  isActive?: boolean;
+}
+
+function toPrismaInput(input: Partial<CustomerInput>): Omit<Partial<CustomerInput>, "dob" | "joinedDate"> & { dob?: Date | null; joinedDate?: Date } {
+  return {
+    ...input,
+    dob: input.dob === undefined ? undefined : input.dob === null ? null : new Date(input.dob),
+    joinedDate: input.joinedDate === undefined ? undefined : new Date(input.joinedDate),
+  };
+}
+
+@Injectable()
+export class CustomerRepository {
+  constructor(@Inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  /** Newest-first, page-paginated; `search` matches name/email/username/phone. Returns raw rows — shaping is the caller's job. */
+  async list(filter: CustomerListFilter = {}): Promise<CustomerListResult> {
+    const page = normalizePage(filter.page);
+    const limit = normalizeLimit(filter.limit);
+    const where: Prisma.CustomerWhereInput = {
+      isDeleted: false,
+      isActive: filter.activeOnly ? true : undefined,
+      OR: filter.search
+        ? [
+            { firstName: { contains: filter.search, mode: "insensitive" } },
+            { lastName: { contains: filter.search, mode: "insensitive" } },
+            { email: { contains: filter.search, mode: "insensitive" } },
+            { username: { contains: filter.search, mode: "insensitive" } },
+            { phone: { contains: filter.search, mode: "insensitive" } },
+          ]
+        : undefined,
+    };
+
+    const [rows, total] = await this.prisma.$transaction([
+      this.prisma.customer.findMany({ where, orderBy: [{ createdAt: "desc" }, { id: "desc" }], take: limit, skip: (page - 1) * limit }),
+      this.prisma.customer.count({ where }),
+    ]);
+
+    return { items: rows.map(toCustomerSummary), meta: buildPageMeta(page, limit, total) };
+  }
+
+  async get(customerId: string): Promise<CustomerSummary> {
+    const row = await this.prisma.customer.findUnique({ where: { id: toId(customerId), isDeleted: false } });
+    if (!row) throw new NotFoundException(`customer "${customerId}" not found`);
+    return toCustomerSummary(row);
+  }
+
+  async create(input: CustomerInput, actorUserId: string | null): Promise<CustomerSummary> {
+    const existing = await this.prisma.customer.findUnique({ where: { email: input.email } });
+    if (existing) throw new ConflictException("a customer with this email already exists");
+
+    const row = await this.prisma.customer.create({
+      data: { ...toPrismaInput(input), email: input.email, createdBy: toIdOrNull(actorUserId), updatedBy: toIdOrNull(actorUserId) },
+    });
+    return toCustomerSummary(row);
+  }
+
+  async update(customerId: string, input: Partial<CustomerInput>, actorUserId: string | null): Promise<CustomerSummary> {
+    const customerIdBig = toId(customerId);
+    const existing = await this.prisma.customer.findUnique({ where: { id: customerIdBig, isDeleted: false }, select: { id: true } });
+    if (!existing) throw new NotFoundException(`customer "${customerId}" not found`);
+
+    if (input.email !== undefined) {
+      const clash = await this.prisma.customer.findFirst({ where: { NOT: { id: customerIdBig }, email: input.email } });
+      if (clash) throw new ConflictException("a customer with this email already exists");
+    }
+
+    const row = await this.prisma.customer.update({
+      where: { id: customerIdBig },
+      data: { ...toPrismaInput(input), updatedBy: toIdOrNull(actorUserId) },
+    });
+    return toCustomerSummary(row);
+  }
+
+  // Soft-delete, matching every other table's isDeleted/deletedAt/deletedBy/deletedReason pattern.
+  async delete(customerId: string, actorUserId: string | null, reason?: string): Promise<void> {
+    const customerIdBig = toId(customerId);
+    const existing = await this.prisma.customer.findUnique({ where: { id: customerIdBig, isDeleted: false }, select: { id: true } });
+    if (!existing) throw new NotFoundException(`customer "${customerId}" not found`);
+    await this.prisma.customer.update({
+      where: { id: customerIdBig },
+      data: { isDeleted: true, deletedAt: new Date(), deletedBy: toIdOrNull(actorUserId), deletedReason: reason ?? null },
+    });
+  }
+
+  async setActive(customerId: string, isActive: boolean, actorUserId: string | null): Promise<void> {
+    const customerIdBig = toId(customerId);
+    const existing = await this.prisma.customer.findUnique({ where: { id: customerIdBig, isDeleted: false }, select: { id: true } });
+    if (!existing) throw new NotFoundException(`customer "${customerId}" not found`);
+    await this.prisma.customer.update({ where: { id: customerIdBig }, data: { isActive, updatedBy: toIdOrNull(actorUserId) } });
+  }
+}

package/registry/combos/nestjs-prisma/variants/base/src/docs.ts

@@ -0,0 +1,60 @@
+import type { INestApplication } from "@nestjs/common";
+import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import type { OpenAPIObject } from "@nestjs/swagger";
+import { apiReference } from "@scalar/nestjs-api-reference";
+import type { NextFunction, Request, Response } from "express";
+
+// Production-only gate: development keeps zero-friction docs, production requires the DOCS_*
+// pair on every docs route. Credentials missing in production fail closed (503), not open.
+export function docsBasicAuth(req: Request, res: Response, next: NextFunction): void {
+  if (process.env["NODE_ENV"] !== "production") return next();
+
+  const username = process.env["DOCS_USERNAME"];
+  const password = process.env["DOCS_PASSWORD"];
+  if (!username || !password) {
+    res.status(503).send("Docs are unavailable: DOCS_USERNAME and DOCS_PASSWORD are not set");
+    return;
+  }
+
+  const header = req.headers.authorization;
+  if (header?.startsWith("Basic ")) {
+    // Split on the first colon only — RFC 7617 allows colons inside the password.
+    const [user, ...rest] = Buffer.from(header.slice("Basic ".length), "base64").toString("utf8").split(":");
+    if (user === username && rest.join(":") === password) return next();
+  }
+
+  res.setHeader("WWW-Authenticate", 'Basic realm="API docs"');
+  res.status(401).send("Authentication required");
+}
+
+export interface DocsOptions {
+  title?: string;
+  description?: string;
+  version?: string;
+}
+
+/**
+ * Swagger UI at `/docs` and a Scalar reference at `/reference`, both (plus the raw spec routes
+ * Swagger registers alongside the UI) behind `docsBasicAuth`. Call after `NestFactory.create`,
+ * before `listen`.
+ */
+export function setupDocs(app: INestApplication, opts: DocsOptions = {}): OpenAPIObject {
+  const document = SwaggerModule.createDocument(
+    app,
+    new DocumentBuilder()
+      .setTitle(opts.title ?? "simple-auth-kit API")
+      .setDescription(opts.description ?? "nestjs-prisma reference combo — signup/login, sessions, TOTP 2FA, OAuth, password reset, RBAC, audit log")
+      .setVersion(opts.version ?? "1.0")
+      .addBearerAuth()
+      .build(),
+  );
+
+  // The gates must be registered before SwaggerModule.setup so they run ahead of the UI
+  // middleware. `/docs-json` and `/docs-yaml` are separate express paths — a `/docs` prefix
+  // mount does not cover them.
+  for (const path of ["/docs", "/docs-json", "/docs-yaml", "/reference"]) app.use(path, docsBasicAuth);
+
+  SwaggerModule.setup("docs", app, document);
+  app.use("/reference", apiReference({ content: document }));
+  return document;
+}

package/registry/combos/nestjs-prisma/variants/base/src/dto/admin.dto.ts

@@ -0,0 +1,130 @@
+// Response shapes for the admin endpoints — the ones that describe *administered principals*
+// rather than the caller's own identity. Kept apart from auth.dto.ts for that reason.
+import { ApiProperty } from "@nestjs/swagger";
+
+export class UserSummaryDto {
+  @ApiProperty({ type: String })
+  id!: string;
+
+  @ApiProperty({ type: String })
+  uuid!: string;
+
+  @ApiProperty({ type: String })
+  email!: string;
+
+  @ApiProperty({ type: String, nullable: true, description: "Unique across the deployment." })
+  firstName!: string | null;
+
+  @ApiProperty({ type: String, nullable: true, description: "Unique across the deployment." })
+  lastName!: string | null;
+
+  @ApiProperty({ type: String, nullable: true })
+  displayName!: string | null;
+
+  @ApiProperty({ type: String, nullable: true, description: "Unique across the deployment." })
+  phone!: string | null;
+
+  @ApiProperty({ type: String, nullable: true, description: "Unique across the deployment." })
+  username!: string | null;
+
+  @ApiProperty({ type: String, nullable: true })
+  photo!: string | null;
+
+  @ApiProperty({ type: String, nullable: true, description: "Date of birth, ISO 8601." })
+  dob!: string | null;
+
+  @ApiProperty({ type: String, nullable: true })
+  gender!: string | null;
+
+  @ApiProperty({ type: String, description: "ISO 8601. Defaults to the account's creation day." })
+  joinedDate!: string;
+
+  @ApiProperty({ type: String, nullable: true, description: "ISO 8601. Set on every successful signup/login/OAuth callback, never on a token refresh." })
+  lastLogin!: string | null;
+
+  @ApiProperty({ type: Boolean, description: "Security/moderation block — distinct from isActive, see the model note." })
+  blocked!: boolean;
+
+  @ApiProperty({ type: Boolean, description: "Routine administrative on/off toggle — distinct from blocked, see the model note." })
+  isActive!: boolean;
+
+  @ApiProperty({ type: Boolean })
+  twoFactorEnabled!: boolean;
+
+  @ApiProperty({ type: [String] })
+  roles!: string[];
+
+  @ApiProperty({ type: String, nullable: true, description: "User id of whoever created this account, if it wasn't a self-signup." })
+  createdBy!: string | null;
+
+  @ApiProperty({ type: String, nullable: true, description: "User id of whoever last edited this account's profile." })
+  updatedBy!: string | null;
+
+  @ApiProperty({ type: String })
+  createdAt!: string;
+
+  @ApiProperty({ type: String })
+  updatedAt!: string;
+}
+
+export class PageMetaDto {
+  @ApiProperty({ type: Number, description: "1-indexed" })
+  page!: number;
+
+  @ApiProperty({ type: Number })
+  limit!: number;
+
+  @ApiProperty({ type: Number })
+  total!: number;
+
+  @ApiProperty({ type: Number })
+  pageCount!: number;
+
+  @ApiProperty({ type: Boolean })
+  hasPreviousPage!: boolean;
+
+  @ApiProperty({ type: Boolean })
+  hasNextPage!: boolean;
+}
+
+export class UserListResponseDto {
+  @ApiProperty({ type: [UserSummaryDto] })
+  items!: UserSummaryDto[];
+
+  @ApiProperty({ type: PageMetaDto })
+  meta!: PageMetaDto;
+}
+
+export class AuditLogEntryDto {
+  @ApiProperty({ type: String })
+  id!: string;
+
+  @ApiProperty({ type: String, nullable: true })
+  userId!: string | null;
+
+  @ApiProperty({ type: String, description: "Human-readable label for `action`", example: "Role assigned" })
+  name!: string;
+
+  @ApiProperty({ type: String, description: "AuditEvent discriminant", example: "role_assigned" })
+  action!: string;
+
+  @ApiProperty({ type: Object, description: "The rest of the AuditEvent's fields" })
+  info!: unknown;
+
+  @ApiProperty({ type: String, nullable: true, description: "Free-text note" })
+  remarks!: string | null;
+
+  @ApiProperty({ type: String })
+  createdAt!: string;
+
+  @ApiProperty({ type: String })
+  updatedAt!: string;
+}
+
+export class AuditLogListResponseDto {
+  @ApiProperty({ type: [AuditLogEntryDto] })
+  items!: AuditLogEntryDto[];
+
+  @ApiProperty({ type: PageMetaDto })
+  meta!: PageMetaDto;
+}

package/registry/combos/nestjs-prisma/variants/base/src/dto/country.dto.ts

@@ -0,0 +1,120 @@
+// Swagger-only DTOs — NOT wired into `@Body()` as the runtime type, same convention as
+// dto/auth.dto.ts: the controller keeps its `Record<string, unknown>` + `requireString()`
+// validation. Every `@ApiProperty` passes an explicit `type` because this repo runs via `tsx`
+// (esbuild), which doesn't reliably emit decorator type metadata for reflection.
+import { ApiProperty } from "@nestjs/swagger";
+import { PageMetaDto } from "./admin.dto.js";
+
+export class CreateCountryDto {
+  @ApiProperty({ type: String, description: "Stable identifier, unique across the deployment.", example: "US" })
+  code!: string;
+
+  @ApiProperty({ type: String, example: "United States" })
+  name!: string;
+
+  @ApiProperty({ type: String, example: "🇺🇸" })
+  emoji!: string;
+
+  @ApiProperty({ type: String, example: "+1" })
+  phoneCode!: string;
+
+  @ApiProperty({ type: String, example: "USD" })
+  currency!: string;
+
+  @ApiProperty({ type: String, example: "US Dollar" })
+  currencyName!: string;
+
+  @ApiProperty({ type: String, description: "Unique across the deployment.", example: "US" })
+  isoCode!: string;
+
+  @ApiProperty({ type: String, required: false, nullable: true, description: "A data URI or an externally-hosted URL — stored as-is, never processed server-side." })
+  flag?: string | null;
+
+  @ApiProperty({ type: Boolean, required: false })
+  isActive?: boolean;
+}
+
+export class UpdateCountryDto {
+  @ApiProperty({ type: String, required: false })
+  code?: string;
+
+  @ApiProperty({ type: String, required: false })
+  name?: string;
+
+  @ApiProperty({ type: String, required: false })
+  emoji?: string;
+
+  @ApiProperty({ type: String, required: false })
+  phoneCode?: string;
+
+  @ApiProperty({ type: String, required: false })
+  currency?: string;
+
+  @ApiProperty({ type: String, required: false })
+  currencyName?: string;
+
+  @ApiProperty({ type: String, required: false })
+  isoCode?: string;
+
+  @ApiProperty({ type: String, required: false, nullable: true, description: "A data URI or an externally-hosted URL — stored as-is, never processed server-side." })
+  flag?: string | null;
+
+  @ApiProperty({ type: Boolean, required: false })
+  isActive?: boolean;
+}
+
+/** Every column the `Country` table has — there is no secret to withhold, unlike `UserSummaryDto`. */
+export class CountrySummaryDto {
+  @ApiProperty({ type: String })
+  id!: string;
+
+  @ApiProperty({ type: String })
+  uuid!: string;
+
+  @ApiProperty({ type: String })
+  code!: string;
+
+  @ApiProperty({ type: String })
+  name!: string;
+
+  @ApiProperty({ type: String })
+  emoji!: string;
+
+  @ApiProperty({ type: String })
+  phoneCode!: string;
+
+  @ApiProperty({ type: String })
+  currency!: string;
+
+  @ApiProperty({ type: String })
+  currencyName!: string;
+
+  @ApiProperty({ type: String })
+  isoCode!: string;
+
+  @ApiProperty({ type: String, nullable: true })
+  flag!: string | null;
+
+  @ApiProperty({ type: Boolean })
+  isActive!: boolean;
+
+  @ApiProperty({ type: String, nullable: true })
+  createdBy!: string | null;
+
+  @ApiProperty({ type: String, nullable: true })
+  updatedBy!: string | null;
+
+  @ApiProperty({ type: String })
+  createdAt!: string;
+
+  @ApiProperty({ type: String })
+  updatedAt!: string;
+}
+
+export class CountryListResponseDto {
+  @ApiProperty({ type: [CountrySummaryDto] })
+  items!: CountrySummaryDto[];
+
+  @ApiProperty({ type: PageMetaDto })
+  meta!: PageMetaDto;
+}