@simple-auth-kit/cli 1.4.2 → 1.5.0

package/registry/combos/nestjs-prisma/variants/base/src/{customer.repository.ts → repositories/customer.repository.ts}

@@ -1,7 +1,17 @@
-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";
+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>;
@@ -78,11 +88,22 @@ export interface CustomerInput {
   isActive?: boolean;
 }
 
-function toPrismaInput(input: Partial<CustomerInput>): Omit<Partial<CustomerInput>, "dob" | "joinedDate"> & { dob?: Date | null; joinedDate?: Date } {
+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),
+    dob:
+      input.dob === undefined
+        ? undefined
+        : input.dob === null
+          ? null
+          : new Date(input.dob),
+    joinedDate:
+      input.joinedDate === undefined ? undefined : new Date(input.joinedDate),
   };
 }
 
@@ -109,37 +130,71 @@ export class CustomerRepository {
     };
 
     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.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) };
+    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 } });
+    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");
+  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) },
+      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> {
+  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`);
+    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 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({
@@ -150,20 +205,44 @@ export class CustomerRepository {
   }
 
   // Soft-delete, matching every other table's isDeleted/deletedAt/deletedBy/deletedReason pattern.
-  async delete(customerId: string, actorUserId: string | null, reason?: string): Promise<void> {
+  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`);
+    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 },
+      data: {
+        isDeleted: true,
+        deletedAt: new Date(),
+        deletedBy: toIdOrNull(actorUserId),
+        deletedReason: reason ?? null,
+      },
     });
   }
 
-  async setActive(customerId: string, isActive: boolean, actorUserId: string | null): Promise<void> {
+  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) } });
+    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/{language.repository.ts → repositories/language.repository.ts}

@@ -1,7 +1,17 @@
-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";
+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 `Language` row as `findUnique`/`findMany` return it. */
 export type LanguageRow = Prisma.LanguageGetPayload<object>;
@@ -78,58 +88,116 @@ export class LanguageRepository {
     };
 
     const [rows, total] = await this.prisma.$transaction([
-      this.prisma.language.findMany({ where, orderBy: [{ createdAt: "desc" }, { id: "desc" }], take: limit, skip: (page - 1) * limit }),
+      this.prisma.language.findMany({
+        where,
+        orderBy: [{ createdAt: "desc" }, { id: "desc" }],
+        take: limit,
+        skip: (page - 1) * limit,
+      }),
       this.prisma.language.count({ where }),
     ]);
 
-    return { items: rows.map(toLanguageSummary), meta: buildPageMeta(page, limit, total) };
+    return {
+      items: rows.map(toLanguageSummary),
+      meta: buildPageMeta(page, limit, total),
+    };
   }
 
   async get(languageId: string): Promise<LanguageSummary> {
-    const row = await this.prisma.language.findUnique({ where: { id: toId(languageId), isDeleted: false } });
+    const row = await this.prisma.language.findUnique({
+      where: { id: toId(languageId), isDeleted: false },
+    });
     if (!row) throw new NotFoundException(`language "${languageId}" not found`);
     return toLanguageSummary(row);
   }
 
-  async create(input: LanguageInput, actorUserId: string | null): Promise<LanguageSummary> {
-    const existing = await this.prisma.language.findUnique({ where: { code: input.code } });
-    if (existing) throw new ConflictException("a language with this code already exists");
+  async create(
+    input: LanguageInput,
+    actorUserId: string | null,
+  ): Promise<LanguageSummary> {
+    const existing = await this.prisma.language.findUnique({
+      where: { code: input.code },
+    });
+    if (existing)
+      throw new ConflictException("a language with this code already exists");
 
     const row = await this.prisma.language.create({
-      data: { ...input, createdBy: toIdOrNull(actorUserId), updatedBy: toIdOrNull(actorUserId) },
+      data: {
+        ...input,
+        createdBy: toIdOrNull(actorUserId),
+        updatedBy: toIdOrNull(actorUserId),
+      },
     });
     return toLanguageSummary(row);
   }
 
-  async update(languageId: string, input: Partial<LanguageInput>, actorUserId: string | null): Promise<LanguageSummary> {
+  async update(
+    languageId: string,
+    input: Partial<LanguageInput>,
+    actorUserId: string | null,
+  ): Promise<LanguageSummary> {
     const languageIdBig = toId(languageId);
-    const existing = await this.prisma.language.findUnique({ where: { id: languageIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`language "${languageId}" not found`);
+    const existing = await this.prisma.language.findUnique({
+      where: { id: languageIdBig, isDeleted: false },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(`language "${languageId}" not found`);
 
     if (input.code !== undefined) {
-      const clash = await this.prisma.language.findFirst({ where: { NOT: { id: languageIdBig }, code: input.code } });
-      if (clash) throw new ConflictException("a language with this code already exists");
+      const clash = await this.prisma.language.findFirst({
+        where: { NOT: { id: languageIdBig }, code: input.code },
+      });
+      if (clash)
+        throw new ConflictException("a language with this code already exists");
     }
 
-    const row = await this.prisma.language.update({ where: { id: languageIdBig }, data: { ...input, updatedBy: toIdOrNull(actorUserId) } });
+    const row = await this.prisma.language.update({
+      where: { id: languageIdBig },
+      data: { ...input, updatedBy: toIdOrNull(actorUserId) },
+    });
     return toLanguageSummary(row);
   }
 
   // Soft-delete, matching every other table's isDeleted/deletedAt/deletedBy/deletedReason pattern.
-  async delete(languageId: string, actorUserId: string | null, reason?: string): Promise<void> {
+  async delete(
+    languageId: string,
+    actorUserId: string | null,
+    reason?: string,
+  ): Promise<void> {
     const languageIdBig = toId(languageId);
-    const existing = await this.prisma.language.findUnique({ where: { id: languageIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`language "${languageId}" not found`);
+    const existing = await this.prisma.language.findUnique({
+      where: { id: languageIdBig, isDeleted: false },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(`language "${languageId}" not found`);
     await this.prisma.language.update({
       where: { id: languageIdBig },
-      data: { isDeleted: true, deletedAt: new Date(), deletedBy: toIdOrNull(actorUserId), deletedReason: reason ?? null },
+      data: {
+        isDeleted: true,
+        deletedAt: new Date(),
+        deletedBy: toIdOrNull(actorUserId),
+        deletedReason: reason ?? null,
+      },
     });
   }
 
-  async setActive(languageId: string, isActive: boolean, actorUserId: string | null): Promise<void> {
+  async setActive(
+    languageId: string,
+    isActive: boolean,
+    actorUserId: string | null,
+  ): Promise<void> {
     const languageIdBig = toId(languageId);
-    const existing = await this.prisma.language.findUnique({ where: { id: languageIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`language "${languageId}" not found`);
-    await this.prisma.language.update({ where: { id: languageIdBig }, data: { isActive, updatedBy: toIdOrNull(actorUserId) } });
+    const existing = await this.prisma.language.findUnique({
+      where: { id: languageIdBig, isDeleted: false },
+      select: { id: true },
+    });
+    if (!existing)
+      throw new NotFoundException(`language "${languageId}" not found`);
+    await this.prisma.language.update({
+      where: { id: languageIdBig },
+      data: { isActive, updatedBy: toIdOrNull(actorUserId) },
+    });
   }
 }