@voyantjs/availability 0.2.0 → 0.3.0

package/dist/routes-pickups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-pickups.d.ts","sourceRoot":"","sources":["../src/routes-pickups.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,KAAK,GAAG,EAIT,MAAM,oBAAoB,CAAA;AAwC3B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mCA0XjC,CAAA"}

package/dist/routes-pickups.js

@@ -0,0 +1,264 @@
+import { Hono } from "hono";
+import { batchIdsSchema, createBatchUpdateSchema, handleBatchDelete, handleBatchUpdate, notFound, } from "./routes-shared.js";
+import { availabilityService } from "./service.js";
+import { availabilityPickupPointListQuerySchema, availabilitySlotPickupListQuerySchema, customPickupAreaListQuerySchema, insertAvailabilityPickupPointSchema, insertAvailabilitySlotPickupSchema, insertCustomPickupAreaSchema, insertLocationPickupTimeSchema, insertPickupGroupSchema, insertPickupLocationSchema, insertProductMeetingConfigSchema, locationPickupTimeListQuerySchema, pickupGroupListQuerySchema, pickupLocationListQuerySchema, productMeetingConfigListQuerySchema, updateAvailabilityPickupPointSchema, updateAvailabilitySlotPickupSchema, updateCustomPickupAreaSchema, updateLocationPickupTimeSchema, updatePickupGroupSchema, updatePickupLocationSchema, updateProductMeetingConfigSchema, } from "./validation.js";
+const batchUpdateAvailabilityPickupPointSchema = createBatchUpdateSchema(updateAvailabilityPickupPointSchema);
+const batchUpdateAvailabilitySlotPickupSchema = createBatchUpdateSchema(updateAvailabilitySlotPickupSchema);
+const batchUpdateProductMeetingConfigSchema = createBatchUpdateSchema(updateProductMeetingConfigSchema);
+const batchUpdatePickupGroupSchema = createBatchUpdateSchema(updatePickupGroupSchema);
+const batchUpdatePickupLocationSchema = createBatchUpdateSchema(updatePickupLocationSchema);
+const batchUpdateLocationPickupTimeSchema = createBatchUpdateSchema(updateLocationPickupTimeSchema);
+const batchUpdateCustomPickupAreaSchema = createBatchUpdateSchema(updateCustomPickupAreaSchema);
+export const availabilityPickupRoutes = new Hono()
+    .get("/pickup-points", async (c) => {
+    const query = availabilityPickupPointListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listPickupPoints(c.get("db"), query));
+})
+    .post("/pickup-points", async (c) => c.json({
+    data: await availabilityService.createPickupPoint(c.get("db"), insertAvailabilityPickupPointSchema.parse(await c.req.json())),
+}, 201))
+    .post("/pickup-points/batch-update", async (c) => {
+    const body = batchUpdateAvailabilityPickupPointSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updatePickupPoint,
+    }));
+})
+    .post("/pickup-points/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deletePickupPoint,
+    }));
+})
+    .get("/pickup-points/:id", async (c) => {
+    const row = await availabilityService.getPickupPointById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Availability pickup point not found");
+})
+    .patch("/pickup-points/:id", async (c) => {
+    const row = await availabilityService.updatePickupPoint(c.get("db"), c.req.param("id"), updateAvailabilityPickupPointSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Availability pickup point not found");
+})
+    .delete("/pickup-points/:id", async (c) => {
+    const row = await availabilityService.deletePickupPoint(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Availability pickup point not found");
+})
+    .get("/slot-pickups", async (c) => {
+    const query = availabilitySlotPickupListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listSlotPickups(c.get("db"), query));
+})
+    .post("/slot-pickups", async (c) => c.json({
+    data: await availabilityService.createSlotPickup(c.get("db"), insertAvailabilitySlotPickupSchema.parse(await c.req.json())),
+}, 201))
+    .post("/slot-pickups/batch-update", async (c) => {
+    const body = batchUpdateAvailabilitySlotPickupSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updateSlotPickup,
+    }));
+})
+    .post("/slot-pickups/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deleteSlotPickup,
+    }));
+})
+    .get("/slot-pickups/:id", async (c) => {
+    const row = await availabilityService.getSlotPickupById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Availability slot pickup not found");
+})
+    .patch("/slot-pickups/:id", async (c) => {
+    const row = await availabilityService.updateSlotPickup(c.get("db"), c.req.param("id"), updateAvailabilitySlotPickupSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Availability slot pickup not found");
+})
+    .delete("/slot-pickups/:id", async (c) => {
+    const row = await availabilityService.deleteSlotPickup(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Availability slot pickup not found");
+})
+    .get("/meeting-configs", async (c) => {
+    const query = productMeetingConfigListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listMeetingConfigs(c.get("db"), query));
+})
+    .post("/meeting-configs", async (c) => c.json({
+    data: await availabilityService.createMeetingConfig(c.get("db"), insertProductMeetingConfigSchema.parse(await c.req.json())),
+}, 201))
+    .post("/meeting-configs/batch-update", async (c) => {
+    const body = batchUpdateProductMeetingConfigSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updateMeetingConfig,
+    }));
+})
+    .post("/meeting-configs/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deleteMeetingConfig,
+    }));
+})
+    .get("/meeting-configs/:id", async (c) => {
+    const row = await availabilityService.getMeetingConfigById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Product meeting config not found");
+})
+    .patch("/meeting-configs/:id", async (c) => {
+    const row = await availabilityService.updateMeetingConfig(c.get("db"), c.req.param("id"), updateProductMeetingConfigSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Product meeting config not found");
+})
+    .delete("/meeting-configs/:id", async (c) => {
+    const row = await availabilityService.deleteMeetingConfig(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Product meeting config not found");
+})
+    .get("/pickup-groups", async (c) => {
+    const query = pickupGroupListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listPickupGroups(c.get("db"), query));
+})
+    .post("/pickup-groups", async (c) => c.json({
+    data: await availabilityService.createPickupGroup(c.get("db"), insertPickupGroupSchema.parse(await c.req.json())),
+}, 201))
+    .post("/pickup-groups/batch-update", async (c) => {
+    const body = batchUpdatePickupGroupSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updatePickupGroup,
+    }));
+})
+    .post("/pickup-groups/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deletePickupGroup,
+    }));
+})
+    .get("/pickup-groups/:id", async (c) => {
+    const row = await availabilityService.getPickupGroupById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Pickup group not found");
+})
+    .patch("/pickup-groups/:id", async (c) => {
+    const row = await availabilityService.updatePickupGroup(c.get("db"), c.req.param("id"), updatePickupGroupSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Pickup group not found");
+})
+    .delete("/pickup-groups/:id", async (c) => {
+    const row = await availabilityService.deletePickupGroup(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Pickup group not found");
+})
+    .get("/pickup-locations", async (c) => {
+    const query = pickupLocationListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listPickupLocations(c.get("db"), query));
+})
+    .post("/pickup-locations", async (c) => c.json({
+    data: await availabilityService.createPickupLocation(c.get("db"), insertPickupLocationSchema.parse(await c.req.json())),
+}, 201))
+    .post("/pickup-locations/batch-update", async (c) => {
+    const body = batchUpdatePickupLocationSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updatePickupLocation,
+    }));
+})
+    .post("/pickup-locations/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deletePickupLocation,
+    }));
+})
+    .get("/pickup-locations/:id", async (c) => {
+    const row = await availabilityService.getPickupLocationById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Pickup location not found");
+})
+    .patch("/pickup-locations/:id", async (c) => {
+    const row = await availabilityService.updatePickupLocation(c.get("db"), c.req.param("id"), updatePickupLocationSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Pickup location not found");
+})
+    .delete("/pickup-locations/:id", async (c) => {
+    const row = await availabilityService.deletePickupLocation(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Pickup location not found");
+})
+    .get("/location-pickup-times", async (c) => {
+    const query = locationPickupTimeListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listLocationPickupTimes(c.get("db"), query));
+})
+    .post("/location-pickup-times", async (c) => c.json({
+    data: await availabilityService.createLocationPickupTime(c.get("db"), insertLocationPickupTimeSchema.parse(await c.req.json())),
+}, 201))
+    .post("/location-pickup-times/batch-update", async (c) => {
+    const body = batchUpdateLocationPickupTimeSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updateLocationPickupTime,
+    }));
+})
+    .post("/location-pickup-times/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deleteLocationPickupTime,
+    }));
+})
+    .get("/location-pickup-times/:id", async (c) => {
+    const row = await availabilityService.getLocationPickupTimeById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Location pickup time not found");
+})
+    .patch("/location-pickup-times/:id", async (c) => {
+    const row = await availabilityService.updateLocationPickupTime(c.get("db"), c.req.param("id"), updateLocationPickupTimeSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Location pickup time not found");
+})
+    .delete("/location-pickup-times/:id", async (c) => {
+    const row = await availabilityService.deleteLocationPickupTime(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Location pickup time not found");
+})
+    .get("/custom-pickup-areas", async (c) => {
+    const query = customPickupAreaListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await availabilityService.listCustomPickupAreas(c.get("db"), query));
+})
+    .post("/custom-pickup-areas", async (c) => c.json({
+    data: await availabilityService.createCustomPickupArea(c.get("db"), insertCustomPickupAreaSchema.parse(await c.req.json())),
+}, 201))
+    .post("/custom-pickup-areas/batch-update", async (c) => {
+    const body = batchUpdateCustomPickupAreaSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: availabilityService.updateCustomPickupArea,
+    }));
+})
+    .post("/custom-pickup-areas/batch-delete", async (c) => {
+    const body = batchIdsSchema.parse(await c.req.json());
+    return c.json(await handleBatchDelete({
+        db: c.get("db"),
+        ids: body.ids,
+        remove: availabilityService.deleteCustomPickupArea,
+    }));
+})
+    .get("/custom-pickup-areas/:id", async (c) => {
+    const row = await availabilityService.getCustomPickupAreaById(c.get("db"), c.req.param("id"));
+    return row ? c.json({ data: row }) : notFound(c, "Custom pickup area not found");
+})
+    .patch("/custom-pickup-areas/:id", async (c) => {
+    const row = await availabilityService.updateCustomPickupArea(c.get("db"), c.req.param("id"), updateCustomPickupAreaSchema.parse(await c.req.json()));
+    return row ? c.json({ data: row }) : notFound(c, "Custom pickup area not found");
+})
+    .delete("/custom-pickup-areas/:id", async (c) => {
+    const row = await availabilityService.deleteCustomPickupArea(c.get("db"), c.req.param("id"));
+    return row ? c.json({ success: true }) : notFound(c, "Custom pickup area not found");
+});

package/dist/routes-shared.d.ts

@@ -0,0 +1,49 @@
+import type { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import type { Context } from "hono";
+import { z } from "zod";
+export type Env = {
+    Variables: {
+        db: PostgresJsDatabase;
+        userId?: string;
+    };
+};
+export declare const batchIdsSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const createBatchUpdateSchema: <TPatch extends z.ZodTypeAny>(patchSchema: TPatch) => z.ZodObject<{
+    ids: z.ZodArray<z.ZodString>;
+    patch: TPatch;
+}, z.core.$strip>;
+export declare function handleBatchUpdate<TPatch, TRow>({ db, ids, patch, update, }: {
+    db: PostgresJsDatabase;
+    ids: string[];
+    patch: TPatch;
+    update: (db: PostgresJsDatabase, id: string, patch: TPatch) => Promise<TRow | null>;
+}): Promise<{
+    data: NonNullable<Awaited<TRow>>[];
+    total: number;
+    succeeded: number;
+    failed: {
+        id: string;
+        error: string;
+    }[];
+}>;
+export declare function handleBatchDelete({ db, ids, remove, }: {
+    db: PostgresJsDatabase;
+    ids: string[];
+    remove: (db: PostgresJsDatabase, id: string) => Promise<{
+        id: string;
+    } | null>;
+}): Promise<{
+    deletedIds: string[];
+    total: number;
+    succeeded: number;
+    failed: {
+        id: string;
+        error: string;
+    }[];
+}>;
+export declare function notFound(c: Context<Env>, message: string): Response & import("hono").TypedResponse<{
+    error: string;
+}, 404, "json">;
+//# sourceMappingURL=routes-shared.d.ts.map

package/dist/routes-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-shared.d.ts","sourceRoot":"","sources":["../src/routes-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,MAAM,MAAM,GAAG,GAAG;IAChB,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAED,eAAO,MAAM,cAAc;;iBAEzB,CAAA;AAEF,eAAO,MAAM,uBAAuB,GAAI,MAAM,SAAS,CAAC,CAAC,UAAU,EAAE,aAAa,MAAM;;;iBAMpF,CAAA;AAEJ,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,IAAI,EAAE,EACpD,EAAE,EACF,GAAG,EACH,KAAK,EACL,MAAM,GACP,EAAE;IACD,EAAE,EAAE,kBAAkB,CAAA;IACtB,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAA;CACpF;;;;;;;;GAmBA;AAED,wBAAsB,iBAAiB,CAAC,EACtC,EAAE,EACF,GAAG,EACH,MAAM,GACP,EAAE;IACD,EAAE,EAAE,kBAAkB,CAAA;IACtB,GAAG,EAAE,MAAM,EAAE,CAAA;IACb,MAAM,EAAE,CAAC,EAAE,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC,CAAA;CAC/E;;;;;;;;GAmBA;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,EAAE,MAAM;;gBAExD"}

package/dist/routes-shared.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export const batchIdsSchema = z.object({
+    ids: z.array(z.string()).min(1).max(200),
+});
+export const createBatchUpdateSchema = (patchSchema) => z.object({
+    ids: batchIdsSchema.shape.ids,
+    patch: patchSchema.refine((value) => Object.keys(value).length > 0, {
+        message: "Patch payload is required",
+    }),
+});
+export async function handleBatchUpdate({ db, ids, patch, update, }) {
+    const results = await Promise.all(ids.map(async (id) => {
+        const row = await update(db, id, patch);
+        return row ? { id, row } : { id, row: null };
+    }));
+    const data = results.flatMap((result) => (result.row ? [result.row] : []));
+    const failed = results
+        .filter((result) => result.row === null)
+        .map((result) => ({ id: result.id, error: "Not found" }));
+    return {
+        data,
+        total: ids.length,
+        succeeded: data.length,
+        failed,
+    };
+}
+export async function handleBatchDelete({ db, ids, remove, }) {
+    const results = await Promise.all(ids.map(async (id) => {
+        const row = await remove(db, id);
+        return row ? { id } : { id, error: "Not found" };
+    }));
+    const deletedIds = results.flatMap((result) => ("error" in result ? [] : [result.id]));
+    const failed = results
+        .filter((result) => "error" in result)
+        .map((result) => ({ id: result.id, error: result.error }));
+    return {
+        deletedIds,
+        total: ids.length,
+        succeeded: deletedIds.length,
+        failed,
+    };
+}
+export function notFound(c, message) {
+    return c.json({ error: message }, 404);
+}