@simple-auth-kit/cli 1.4.2 → 1.5.0

package/registry/combos/nestjs-prisma/variants/workspaces/src/{country.repository.ts → repositories/country.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 `Country` row as `findUnique`/`findMany` return it. */
 export type CountryRow = Prisma.CountryGetPayload<object>;
@@ -78,7 +88,10 @@ 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(workspaceId: string, filter: CountryListFilter = {}): Promise<CountryListResult> {
+  async list(
+    workspaceId: string,
+    filter: CountryListFilter = {},
+  ): Promise<CountryListResult> {
     const page = normalizePage(filter.page);
     const limit = normalizeLimit(filter.limit);
     const where: Prisma.CountryWhereInput = {
@@ -95,64 +108,152 @@ export class CountryRepository {
     };
 
     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.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) };
+    return {
+      items: rows.map(toCountrySummary),
+      meta: buildPageMeta(page, limit, total),
+    };
   }
 
   async get(workspaceId: string, countryId: string): Promise<CountrySummary> {
-    const row = await this.prisma.country.findUnique({ where: { id: toId(countryId), workspaceId: toId(workspaceId), isDeleted: false } });
+    const row = await this.prisma.country.findUnique({
+      where: {
+        id: toId(countryId),
+        workspaceId: toId(workspaceId),
+        isDeleted: false,
+      },
+    });
     if (!row) throw new NotFoundException(`country "${countryId}" not found`);
     return toCountrySummary(row);
   }
 
-  async create(workspaceId: string, input: CountryInput, actorUserId: string | null): Promise<CountrySummary> {
+  async create(
+    workspaceId: string,
+    input: CountryInput,
+    actorUserId: string | null,
+  ): Promise<CountrySummary> {
     const workspaceIdBig = toId(workspaceId);
-    const existing = await this.prisma.country.findFirst({ where: { workspaceId: workspaceIdBig, OR: [{ code: input.code }, { isoCode: input.isoCode }] } });
-    if (existing) throw new ConflictException("a country with this code or ISO code already exists in this workspace");
+    const existing = await this.prisma.country.findFirst({
+      where: {
+        workspaceId: workspaceIdBig,
+        OR: [{ code: input.code }, { isoCode: input.isoCode }],
+      },
+    });
+    if (existing)
+      throw new ConflictException(
+        "a country with this code or ISO code already exists in this workspace",
+      );
 
     const row = await this.prisma.country.create({
-      data: { ...input, workspaceId: workspaceIdBig, createdBy: toIdOrNull(actorUserId), updatedBy: toIdOrNull(actorUserId) },
+      data: {
+        ...input,
+        workspaceId: workspaceIdBig,
+        createdBy: toIdOrNull(actorUserId),
+        updatedBy: toIdOrNull(actorUserId),
+      },
     });
     return toCountrySummary(row);
   }
 
-  async update(workspaceId: string, countryId: string, input: Partial<CountryInput>, actorUserId: string | null): Promise<CountrySummary> {
+  async update(
+    workspaceId: string,
+    countryId: string,
+    input: Partial<CountryInput>,
+    actorUserId: string | null,
+  ): Promise<CountrySummary> {
     const workspaceIdBig = toId(workspaceId);
     const countryIdBig = toId(countryId);
-    const existing = await this.prisma.country.findUnique({ where: { id: countryIdBig, workspaceId: workspaceIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`country "${countryId}" not found`);
+    const existing = await this.prisma.country.findUnique({
+      where: {
+        id: countryIdBig,
+        workspaceId: workspaceIdBig,
+        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: { workspaceId: workspaceIdBig, NOT: { id: countryIdBig }, OR: [{ code: input.code }, { isoCode: input.isoCode }] },
+        where: {
+          workspaceId: workspaceIdBig,
+          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 in this workspace");
+      if (clash)
+        throw new ConflictException(
+          "a country with this code or ISO code already exists in this workspace",
+        );
     }
 
-    const row = await this.prisma.country.update({ where: { id: countryIdBig }, data: { ...input, updatedBy: toIdOrNull(actorUserId) } });
+    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(workspaceId: string, countryId: string, actorUserId: string | null, reason?: string): Promise<void> {
+  async delete(
+    workspaceId: string,
+    countryId: string,
+    actorUserId: string | null,
+    reason?: string,
+  ): Promise<void> {
     const workspaceIdBig = toId(workspaceId);
     const countryIdBig = toId(countryId);
-    const existing = await this.prisma.country.findUnique({ where: { id: countryIdBig, workspaceId: workspaceIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`country "${countryId}" not found`);
+    const existing = await this.prisma.country.findUnique({
+      where: {
+        id: countryIdBig,
+        workspaceId: workspaceIdBig,
+        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 },
+      data: {
+        isDeleted: true,
+        deletedAt: new Date(),
+        deletedBy: toIdOrNull(actorUserId),
+        deletedReason: reason ?? null,
+      },
     });
   }
 
-  async setActive(workspaceId: string, countryId: string, isActive: boolean, actorUserId: string | null): Promise<void> {
+  async setActive(
+    workspaceId: string,
+    countryId: string,
+    isActive: boolean,
+    actorUserId: string | null,
+  ): Promise<void> {
     const workspaceIdBig = toId(workspaceId);
     const countryIdBig = toId(countryId);
-    const existing = await this.prisma.country.findUnique({ where: { id: countryIdBig, workspaceId: workspaceIdBig, 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) } });
+    const existing = await this.prisma.country.findUnique({
+      where: {
+        id: countryIdBig,
+        workspaceId: workspaceIdBig,
+        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/workspaces/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),
   };
 }
 
@@ -96,7 +117,10 @@ 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(workspaceId: string, filter: CustomerListFilter = {}): Promise<CustomerListResult> {
+  async list(
+    workspaceId: string,
+    filter: CustomerListFilter = {},
+  ): Promise<CustomerListResult> {
     const page = normalizePage(filter.page);
     const limit = normalizeLimit(filter.limit);
     const where: Prisma.CustomerWhereInput = {
@@ -115,39 +139,90 @@ 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(workspaceId: string, customerId: string): Promise<CustomerSummary> {
-    const row = await this.prisma.customer.findUnique({ where: { id: toId(customerId), workspaceId: toId(workspaceId), isDeleted: false } });
+    const row = await this.prisma.customer.findUnique({
+      where: {
+        id: toId(customerId),
+        workspaceId: toId(workspaceId),
+        isDeleted: false,
+      },
+    });
     if (!row) throw new NotFoundException(`customer "${customerId}" not found`);
     return toCustomerSummary(row);
   }
 
-  async create(workspaceId: string, input: CustomerInput, actorUserId: string | null): Promise<CustomerSummary> {
+  async create(
+    workspaceId: string,
+    input: CustomerInput,
+    actorUserId: string | null,
+  ): Promise<CustomerSummary> {
     const workspaceIdBig = toId(workspaceId);
-    const existing = await this.prisma.customer.findFirst({ where: { workspaceId: workspaceIdBig, email: input.email } });
-    if (existing) throw new ConflictException("a customer with this email already exists in this workspace");
+    const existing = await this.prisma.customer.findFirst({
+      where: { workspaceId: workspaceIdBig, email: input.email },
+    });
+    if (existing)
+      throw new ConflictException(
+        "a customer with this email already exists in this workspace",
+      );
 
     const row = await this.prisma.customer.create({
-      data: { ...toPrismaInput(input), email: input.email, workspaceId: workspaceIdBig, createdBy: toIdOrNull(actorUserId), updatedBy: toIdOrNull(actorUserId) },
+      data: {
+        ...toPrismaInput(input),
+        email: input.email,
+        workspaceId: workspaceIdBig,
+        createdBy: toIdOrNull(actorUserId),
+        updatedBy: toIdOrNull(actorUserId),
+      },
     });
     return toCustomerSummary(row);
   }
 
-  async update(workspaceId: string, customerId: string, input: Partial<CustomerInput>, actorUserId: string | null): Promise<CustomerSummary> {
+  async update(
+    workspaceId: string,
+    customerId: string,
+    input: Partial<CustomerInput>,
+    actorUserId: string | null,
+  ): Promise<CustomerSummary> {
     const workspaceIdBig = toId(workspaceId);
     const customerIdBig = toId(customerId);
-    const existing = await this.prisma.customer.findUnique({ where: { id: customerIdBig, workspaceId: workspaceIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`customer "${customerId}" not found`);
+    const existing = await this.prisma.customer.findUnique({
+      where: {
+        id: customerIdBig,
+        workspaceId: workspaceIdBig,
+        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: { workspaceId: workspaceIdBig, NOT: { id: customerIdBig }, email: input.email } });
-      if (clash) throw new ConflictException("a customer with this email already exists in this workspace");
+      const clash = await this.prisma.customer.findFirst({
+        where: {
+          workspaceId: workspaceIdBig,
+          NOT: { id: customerIdBig },
+          email: input.email,
+        },
+      });
+      if (clash)
+        throw new ConflictException(
+          "a customer with this email already exists in this workspace",
+        );
     }
 
     const row = await this.prisma.customer.update({
@@ -158,22 +233,56 @@ export class CustomerRepository {
   }
 
   // Soft-delete, matching every other table's isDeleted/deletedAt/deletedBy/deletedReason pattern.
-  async delete(workspaceId: string, customerId: string, actorUserId: string | null, reason?: string): Promise<void> {
+  async delete(
+    workspaceId: string,
+    customerId: string,
+    actorUserId: string | null,
+    reason?: string,
+  ): Promise<void> {
     const workspaceIdBig = toId(workspaceId);
     const customerIdBig = toId(customerId);
-    const existing = await this.prisma.customer.findUnique({ where: { id: customerIdBig, workspaceId: workspaceIdBig, isDeleted: false }, select: { id: true } });
-    if (!existing) throw new NotFoundException(`customer "${customerId}" not found`);
+    const existing = await this.prisma.customer.findUnique({
+      where: {
+        id: customerIdBig,
+        workspaceId: workspaceIdBig,
+        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(workspaceId: string, customerId: string, isActive: boolean, actorUserId: string | null): Promise<void> {
+  async setActive(
+    workspaceId: string,
+    customerId: string,
+    isActive: boolean,
+    actorUserId: string | null,
+  ): Promise<void> {
     const workspaceIdBig = toId(workspaceId);
     const customerIdBig = toId(customerId);
-    const existing = await this.prisma.customer.findUnique({ where: { id: customerIdBig, workspaceId: workspaceIdBig, 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,
+        workspaceId: workspaceIdBig,
+        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/workspaces/src/repositories/language.repository.ts

@@ -0,0 +1,243 @@
+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>;
+
+/** Every column the `Language` table has — no secret to withhold, same reasoning as `toUserSummary`. */
+export interface LanguageSummary {
+  id: string;
+  uuid: string;
+  code: string;
+  name: string;
+  nativeName: string;
+  direction: string;
+  isDefault: boolean;
+  isActive: boolean;
+  createdBy: string | null;
+  updatedBy: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export function toLanguageSummary(row: LanguageRow): LanguageSummary {
+  return {
+    id: row.id.toString(),
+    uuid: row.uuid,
+    code: row.code,
+    name: row.name,
+    nativeName: row.nativeName,
+    direction: row.direction,
+    isDefault: row.isDefault,
+    isActive: row.isActive,
+    createdBy: row.createdBy?.toString() ?? null,
+    updatedBy: row.updatedBy?.toString() ?? null,
+    createdAt: row.createdAt.toISOString(),
+    updatedAt: row.updatedAt.toISOString(),
+  };
+}
+
+export interface LanguageListFilter {
+  search?: string;
+  page?: number;
+  limit?: number;
+  activeOnly?: boolean;
+}
+
+export type LanguageListResult = Paginated<LanguageSummary>;
+
+export interface LanguageInput {
+  code: string;
+  name: string;
+  nativeName: string;
+  direction?: string;
+  isDefault?: boolean;
+  isActive?: boolean;
+}
+
+// Every method takes `workspaceId` first, matching `WorkspaceRepository`'s signature style, and
+// every query's `where` includes it — a language lives in exactly one workspace, and `code`
+// uniqueness is checked within that workspace only (see `schema.prisma`'s composite unique constraint).
+@Injectable()
+export class LanguageRepository {
+  constructor(@Inject(PrismaClient) private readonly prisma: PrismaClient) {}
+
+  /** Newest-first, page-paginated; `search` matches name/code/nativeName. Returns raw rows — shaping is the caller's job. */
+  async list(
+    workspaceId: string,
+    filter: LanguageListFilter = {},
+  ): Promise<LanguageListResult> {
+    const page = normalizePage(filter.page);
+    const limit = normalizeLimit(filter.limit);
+    const where: Prisma.LanguageWhereInput = {
+      workspaceId: toId(workspaceId),
+      isDeleted: false,
+      isActive: filter.activeOnly ? true : undefined,
+      OR: filter.search
+        ? [
+            { name: { contains: filter.search, mode: "insensitive" } },
+            { code: { contains: filter.search, mode: "insensitive" } },
+            { nativeName: { contains: filter.search, mode: "insensitive" } },
+          ]
+        : undefined,
+    };
+
+    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.count({ where }),
+    ]);
+
+    return {
+      items: rows.map(toLanguageSummary),
+      meta: buildPageMeta(page, limit, total),
+    };
+  }
+
+  async get(workspaceId: string, languageId: string): Promise<LanguageSummary> {
+    const row = await this.prisma.language.findUnique({
+      where: {
+        id: toId(languageId),
+        workspaceId: toId(workspaceId),
+        isDeleted: false,
+      },
+    });
+    if (!row) throw new NotFoundException(`language "${languageId}" not found`);
+    return toLanguageSummary(row);
+  }
+
+  async create(
+    workspaceId: string,
+    input: LanguageInput,
+    actorUserId: string | null,
+  ): Promise<LanguageSummary> {
+    const workspaceIdBig = toId(workspaceId);
+    const existing = await this.prisma.language.findFirst({
+      where: { workspaceId: workspaceIdBig, code: input.code },
+    });
+    if (existing)
+      throw new ConflictException(
+        "a language with this code already exists in this workspace",
+      );
+
+    const row = await this.prisma.language.create({
+      data: {
+        ...input,
+        workspaceId: workspaceIdBig,
+        createdBy: toIdOrNull(actorUserId),
+        updatedBy: toIdOrNull(actorUserId),
+      },
+    });
+    return toLanguageSummary(row);
+  }
+
+  async update(
+    workspaceId: string,
+    languageId: string,
+    input: Partial<LanguageInput>,
+    actorUserId: string | null,
+  ): Promise<LanguageSummary> {
+    const workspaceIdBig = toId(workspaceId);
+    const languageIdBig = toId(languageId);
+    const existing = await this.prisma.language.findUnique({
+      where: {
+        id: languageIdBig,
+        workspaceId: workspaceIdBig,
+        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: {
+          workspaceId: workspaceIdBig,
+          NOT: { id: languageIdBig },
+          code: input.code,
+        },
+      });
+      if (clash)
+        throw new ConflictException(
+          "a language with this code already exists in this workspace",
+        );
+    }
+
+    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(
+    workspaceId: string,
+    languageId: string,
+    actorUserId: string | null,
+    reason?: string,
+  ): Promise<void> {
+    const workspaceIdBig = toId(workspaceId);
+    const languageIdBig = toId(languageId);
+    const existing = await this.prisma.language.findUnique({
+      where: {
+        id: languageIdBig,
+        workspaceId: workspaceIdBig,
+        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,
+      },
+    });
+  }
+
+  async setActive(
+    workspaceId: string,
+    languageId: string,
+    isActive: boolean,
+    actorUserId: string | null,
+  ): Promise<void> {
+    const workspaceIdBig = toId(workspaceId);
+    const languageIdBig = toId(languageId);
+    const existing = await this.prisma.language.findUnique({
+      where: {
+        id: languageIdBig,
+        workspaceId: workspaceIdBig,
+        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) },
+    });
+  }
+}