feat: 스케줄 추천 정책 통합

apps/api/src/modules/availability/availability.service.spec.ts

@@ -48,12 +48,40 @@ const createBusinessHourRow = ({
   updatedAt: timestamp,
 });
 
+const createMinimumStaffingRuleRow = ({
+  id = BigInt(1),
+  organizationId = BigInt(1),
+  dayOfWeek = "WED",
+  startTime = timeOfDay("09:00"),
+  endTime = timeOfDay("18:00"),
+  endsNextDay = false,
+  requiredCount = 1,
+} = {}) => ({
+  id,
+  organizationId,
+  dayOfWeek,
+  startTime,
+  endTime,
+  endsNextDay,
+  requiredCount,
+  createdAt: timestamp,
+  updatedAt: timestamp,
+});
+
 const createPrismaMock = ({
-  organization = { id: BigInt(1), businessHours: [createBusinessHourRow()] },
+  organization = {
+    id: BigInt(1),
+    businessHours: [createBusinessHourRow()],
+    minimumStaffingRules: [createMinimumStaffingRuleRow()],
+  },
   worker = { id: BigInt(1) },
   workerAvailableTime = {},
 }: {
-  organization?: { businessHours: ReturnType<typeof createBusinessHourRow>[]; id: bigint } | null;
+  organization?: {
+    businessHours: ReturnType<typeof createBusinessHourRow>[];
+    id: bigint;
+    minimumStaffingRules: ReturnType<typeof createMinimumStaffingRuleRow>[];
+  } | null;
   worker?: { id: bigint } | null;
   workerAvailableTime?: {
     createMany?: jest.Mock;
@@ -65,15 +93,27 @@ const createPrismaMock = ({
     .fn<() => Promise<{ id: bigint } | null>>()
     .mockResolvedValue(organization);
   const workerFindFirst = jest.fn<() => Promise<{ id: bigint } | null>>().mockResolvedValue(worker);
+  const workerAvailableTimeCreateMany =
+    workerAvailableTime.createMany ??
+    jest.fn<() => Promise<{ count: number }>>().mockResolvedValue({ count: 0 });
+  const workerAvailableTimeDeleteMany =
+    workerAvailableTime.deleteMany ??
+    jest.fn<() => Promise<{ count: number }>>().mockResolvedValue({ count: 0 });
+  const workerAvailableTimeFindMany =
+    workerAvailableTime.findMany ??
+    jest.fn<() => Promise<ReturnType<typeof createAvailabilityRow>[]>>().mockResolvedValue([]);
 
   return {
     prisma: {
+      activeSchedulePlanningPeriod: {
+        findUnique: jest.fn<() => Promise<null>>().mockResolvedValue(null),
+      },
       $transaction: jest.fn(async (callback: (transaction: unknown) => unknown) =>
         callback({
           workerAvailableTime: {
-            createMany: workerAvailableTime.createMany ?? jest.fn(),
-            deleteMany: workerAvailableTime.deleteMany ?? jest.fn(),
-            findMany: workerAvailableTime.findMany ?? jest.fn(),
+            createMany: workerAvailableTimeCreateMany,
+            deleteMany: workerAvailableTimeDeleteMany,
+            findMany: workerAvailableTimeFindMany,
           },
         }),
       ),
@@ -84,9 +124,9 @@ const createPrismaMock = ({
         findFirst: workerFindFirst,
       },
       workerAvailableTime: {
-        createMany: workerAvailableTime.createMany ?? jest.fn(),
-        deleteMany: workerAvailableTime.deleteMany ?? jest.fn(),
-        findMany: workerAvailableTime.findMany ?? jest.fn(),
+        createMany: workerAvailableTimeCreateMany,
+        deleteMany: workerAvailableTimeDeleteMany,
+        findMany: workerAvailableTimeFindMany,
       },
     } as unknown as PrismaClient,
     organizationFindUnique,
@@ -334,6 +374,7 @@ describe("replaceAvailability", () => {
   });
 
   it("rejects availability on closed days", async () => {
+    const availableTimeCreateMany = jest.fn();
     const { prisma } = createPrismaMock({
       organization: {
         id: BigInt(1),
@@ -344,6 +385,10 @@ describe("replaceAvailability", () => {
             closeTime: null,
           }),
         ],
+        minimumStaffingRules: [createMinimumStaffingRuleRow()],
+      },
+      workerAvailableTime: {
+        createMany: availableTimeCreateMany,
       },
     });
 
@@ -360,14 +405,19 @@ describe("replaceAvailability", () => {
           },
         ],
       }),
-    ).rejects.toMatchObject({
-      code: ERROR_CODES.CLOSED_DAY,
-      statusCode: 400,
+    ).resolves.toEqual({
+      items: [],
     });
+    expect(availableTimeCreateMany).not.toHaveBeenCalled();
   });
 
-  it("rejects availability outside business hours", async () => {
-    const { prisma } = createPrismaMock();
+  it("trims availability to schedulable ranges", async () => {
+    const availableTimeCreateMany = jest.fn();
+    const { prisma } = createPrismaMock({
+      workerAvailableTime: {
+        createMany: availableTimeCreateMany,
+      },
+    });
 
     await expect(
       replaceAvailability(prisma, "1", {
@@ -382,9 +432,18 @@ describe("replaceAvailability", () => {
           },
         ],
       }),
-    ).rejects.toMatchObject({
-      code: ERROR_CODES.INVALID_TIME_RANGE,
-      statusCode: 400,
+    ).resolves.toEqual({
+      items: [],
+    });
+    expect(availableTimeCreateMany).toHaveBeenCalledWith({
+      data: [
+        {
+          workerId: BigInt(1),
+          availableDate: dateOnly("2026-07-01"),
+          startsAt: new Date("2026-07-01T09:00:00.000Z"),
+          endsAt: new Date("2026-07-01T10:00:00.000Z"),
+        },
+      ],
     });
   });
 
@@ -437,6 +496,14 @@ describe("replaceAvailability", () => {
             closesNextDay: true,
           }),
         ],
+        minimumStaffingRules: [
+          createMinimumStaffingRuleRow({
+            dayOfWeek: "FRI",
+            startTime: timeOfDay("22:00"),
+            endTime: timeOfDay("02:00"),
+            endsNextDay: true,
+          }),
+        ],
       },
       workerAvailableTime: {
         createMany: availableTimeCreateMany,

apps/api/src/modules/availability/availability.service.ts

@@ -13,27 +13,21 @@ import type {
 import { ERROR_CODES } from "@/common/constants/error-codes";
 import { HttpError } from "@/errors/http-error";
 import {
-  addDays,
-  createDateTimeOnDate,
-  dateStringToDate,
-  dateTimeStringToDate,
-  dateToDateString,
-} from "@/utils/date-time";
-import { getDayOfWeek } from "@/utils/day-of-week";
+  pruneAvailabilityTimesToSchedulableRanges,
+  type PrunedAvailabilityTime,
+} from "@/modules/scheduling-time-policy";
+import { dateStringToDate, dateTimeStringToDate, dateToDateString } from "@/utils/date-time";
 import { toApiId, toPrismaId } from "@/utils/mapper";
 
 type AvailabilityDatabaseClient = PrismaClient | Prisma.TransactionClient;
 
 type OrganizationForAvailability = Prisma.OrganizationGetPayload<{
-  include: { businessHours: true };
+  include: { businessHours: true; minimumStaffingRules: true };
 }>;
 
 const createInvalidTimeRangeError = () =>
   new HttpError(400, ERROR_CODES.INVALID_TIME_RANGE, "가능 시간이 조직 운영시간을 벗어났습니다.");
 
-const createClosedDayError = () =>
-  new HttpError(400, ERROR_CODES.CLOSED_DAY, "휴무일에는 가능 시간을 저장할 수 없습니다.");
-
 const findOrganizationByUserId = async (
   prisma: PrismaClient,
   userId: string,
@@ -44,6 +38,7 @@ const findOrganizationByUserId = async (
     },
     include: {
       businessHours: true,
+      minimumStaffingRules: true,
     },
   });
 
@@ -77,41 +72,34 @@ const toAvailability = (availability: PrismaWorkerAvailableTime): Availability =
   endsAt: availability.endsAt.toISOString(),
 });
 
-const assertAvailabilityItemInBusinessHours = (
-  organization: OrganizationForAvailability,
-  input: ReplaceAvailabilityRequest,
-) => {
+const isPrismaClient = (client: AvailabilityDatabaseClient): client is PrismaClient =>
+  "$transaction" in client;
+
+const assertAvailabilityItemsInDateRange = (input: ReplaceAvailabilityRequest) => {
   for (const item of input.items) {
     if (item.availableDate < input.startDate || item.availableDate > input.endDate) {
       throw createInvalidTimeRangeError();
     }
 
-    const availableDate = dateStringToDate(item.availableDate);
-    const businessHour = organization.businessHours.find(
-      (currentBusinessHour) => currentBusinessHour.dayOfWeek === getDayOfWeek(availableDate),
-    );
-
-    if (
-      !businessHour ||
-      businessHour.isClosed ||
-      !businessHour.openTime ||
-      !businessHour.closeTime
-    ) {
-      throw createClosedDayError();
-    }
-
-    const startsAt = dateTimeStringToDate(item.startsAt);
-    const endsAt = dateTimeStringToDate(item.endsAt);
-    const openAt = createDateTimeOnDate(availableDate, businessHour.openTime);
-    const closeDate = businessHour.closesNextDay ? addDays(availableDate, 1) : availableDate;
-    const closeAt = createDateTimeOnDate(closeDate, businessHour.closeTime);
-
-    if (startsAt >= endsAt || startsAt < openAt || endsAt > closeAt) {
+    if (dateTimeStringToDate(item.startsAt) >= dateTimeStringToDate(item.endsAt)) {
       throw createInvalidTimeRangeError();
     }
   }
 };
 
+const createPrunedAvailabilityItems = (
+  organization: OrganizationForAvailability,
+  availableTimes: Pick<
+    PrismaWorkerAvailableTime,
+    "availableDate" | "endsAt" | "startsAt" | "workerId"
+  >[],
+): PrunedAvailabilityTime[] =>
+  pruneAvailabilityTimesToSchedulableRanges({
+    availableTimes,
+    businessHours: organization.businessHours,
+    rules: organization.minimumStaffingRules,
+  });
+
 export async function listAvailability(
   prisma: PrismaClient,
   userId: string,
@@ -126,6 +114,8 @@ export async function listAvailability(
     throw new HttpError(404, ERROR_CODES.WORKER_NOT_FOUND, "근무자를 찾을 수 없습니다.");
   }
 
+  await pruneOrganizationAvailabilityForActivePlanningPeriod(prisma, organizationId);
+
   const items = await prisma.workerAvailableTime.findMany({
     where: {
       workerId,
@@ -156,7 +146,17 @@ export async function replaceAvailability(
     throw new HttpError(404, ERROR_CODES.WORKER_NOT_FOUND, "근무자를 찾을 수 없습니다.");
   }
 
-  assertAvailabilityItemInBusinessHours(organization, input);
+  assertAvailabilityItemsInDateRange(input);
+
+  const prunedItems = createPrunedAvailabilityItems(
+    organization,
+    input.items.map((item) => ({
+      workerId,
+      availableDate: dateStringToDate(item.availableDate),
+      startsAt: dateTimeStringToDate(item.startsAt),
+      endsAt: dateTimeStringToDate(item.endsAt),
+    })),
+  );
 
   return prisma.$transaction(async (transaction) => {
     const dateRange = {
@@ -171,14 +171,9 @@ export async function replaceAvailability(
       },
     });
 
-    if (input.items.length > 0) {
+    if (prunedItems.length > 0) {
       await transaction.workerAvailableTime.createMany({
-        data: input.items.map((item) => ({
-          workerId,
-          availableDate: dateStringToDate(item.availableDate),
-          startsAt: dateTimeStringToDate(item.startsAt),
-          endsAt: dateTimeStringToDate(item.endsAt),
-        })),
+        data: prunedItems,
       });
     }
 
@@ -195,3 +190,71 @@ export async function replaceAvailability(
     };
   });
 }
+
+export async function pruneOrganizationAvailabilityForActivePlanningPeriod(
+  client: AvailabilityDatabaseClient,
+  organizationId: bigint,
+): Promise<void> {
+  const activePeriod = await client.activeSchedulePlanningPeriod.findUnique({
+    where: {
+      organizationId,
+    },
+  });
+
+  if (!activePeriod) {
+    return;
+  }
+
+  const organization = await client.organization.findUnique({
+    where: {
+      id: organizationId,
+    },
+    include: {
+      businessHours: true,
+      minimumStaffingRules: true,
+    },
+  });
+
+  if (!organization) {
+    return;
+  }
+
+  const dateRange = {
+    gte: activePeriod.startDate,
+    lte: activePeriod.endDate,
+  };
+  const existingItems = await client.workerAvailableTime.findMany({
+    where: {
+      worker: {
+        organizationId,
+      },
+      availableDate: dateRange,
+    },
+    orderBy: [{ availableDate: "asc" }, { startsAt: "asc" }],
+  });
+  const prunedItems = createPrunedAvailabilityItems(organization, existingItems);
+
+  const replaceAvailability = async (transaction: AvailabilityDatabaseClient) => {
+    await transaction.workerAvailableTime.deleteMany({
+      where: {
+        worker: {
+          organizationId,
+        },
+        availableDate: dateRange,
+      },
+    });
+
+    if (prunedItems.length > 0) {
+      await transaction.workerAvailableTime.createMany({
+        data: prunedItems,
+      });
+    }
+  };
+
+  if (isPrismaClient(client)) {
+    await client.$transaction(replaceAvailability);
+    return;
+  }
+
+  await replaceAvailability(client);
+}