@voyantjs/resources 0.1.0

package/dist/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../src/routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAA;AAyBjE,KAAK,GAAG,GAAG;IACT,SAAS,EAAE;QACT,EAAE,EAAE,kBAAkB,CAAA;QACtB,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAA;CACF,CAAA;AAoFD,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0WxB,CAAA;AAEJ,MAAM,MAAM,eAAe,GAAG,OAAO,eAAe,CAAA"}

package/dist/routes.js

@@ -0,0 +1,330 @@
+import { Hono } from "hono";
+import { z } from "zod";
+import { resourcesService } from "./service.js";
+import { insertResourceCloseoutSchema, insertResourcePoolMemberSchema, insertResourcePoolSchema, insertResourceRequirementSchema, insertResourceSchema, insertResourceSlotAssignmentSchema, resourceCloseoutListQuerySchema, resourceListQuerySchema, resourcePoolListQuerySchema, resourcePoolMemberListQuerySchema, resourceRequirementListQuerySchema, resourceSlotAssignmentListQuerySchema, updateResourceCloseoutSchema, updateResourcePoolSchema, updateResourceRequirementSchema, updateResourceSchema, updateResourceSlotAssignmentSchema, } from "./validation.js";
+const batchIdsSchema = z.object({
+    ids: z.array(z.string()).min(1).max(200),
+});
+const createBatchUpdateSchema = (patchSchema) => z.object({
+    ids: batchIdsSchema.shape.ids,
+    patch: patchSchema.refine((value) => Object.keys(value).length > 0, {
+        message: "Patch payload is required",
+    }),
+});
+const batchUpdateResourceSchema = createBatchUpdateSchema(updateResourceSchema);
+const batchUpdateResourcePoolSchema = createBatchUpdateSchema(updateResourcePoolSchema);
+const batchUpdateResourceRequirementSchema = createBatchUpdateSchema(updateResourceRequirementSchema);
+const batchUpdateResourceSlotAssignmentSchema = createBatchUpdateSchema(updateResourceSlotAssignmentSchema);
+const batchUpdateResourceCloseoutSchema = createBatchUpdateSchema(updateResourceCloseoutSchema);
+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,
+    };
+}
+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 const resourcesRoutes = new Hono()
+    .get("/resources", async (c) => {
+    const query = resourceListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listResources(c.get("db"), query));
+})
+    .post("/resources", async (c) => {
+    return c.json({
+        data: await resourcesService.createResource(c.get("db"), insertResourceSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .post("/resources/batch-update", async (c) => {
+    const body = batchUpdateResourceSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: resourcesService.updateResource,
+    }));
+})
+    .post("/resources/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: resourcesService.deleteResource,
+    }));
+})
+    .get("/resources/:id", async (c) => {
+    const row = await resourcesService.getResourceById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/resources/:id", async (c) => {
+    const row = await resourcesService.updateResource(c.get("db"), c.req.param("id"), updateResourceSchema.parse(await c.req.json()));
+    if (!row)
+        return c.json({ error: "Resource not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/resources/:id", async (c) => {
+    const row = await resourcesService.deleteResource(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/pools", async (c) => {
+    const query = resourcePoolListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listPools(c.get("db"), query));
+})
+    .post("/pools", async (c) => {
+    return c.json({
+        data: await resourcesService.createPool(c.get("db"), insertResourcePoolSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .post("/pools/batch-update", async (c) => {
+    const body = batchUpdateResourcePoolSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: resourcesService.updatePool,
+    }));
+})
+    .post("/pools/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: resourcesService.deletePool,
+    }));
+})
+    .get("/pools/:id", async (c) => {
+    const row = await resourcesService.getPoolById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource pool not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/pools/:id", async (c) => {
+    const row = await resourcesService.updatePool(c.get("db"), c.req.param("id"), updateResourcePoolSchema.parse(await c.req.json()));
+    if (!row)
+        return c.json({ error: "Resource pool not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/pools/:id", async (c) => {
+    const row = await resourcesService.deletePool(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource pool not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/pool-members", async (c) => {
+    const query = resourcePoolMemberListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listPoolMembers(c.get("db"), query));
+})
+    .post("/pool-members", async (c) => {
+    return c.json({
+        data: await resourcesService.createPoolMember(c.get("db"), insertResourcePoolMemberSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .delete("/pool-members/:id", async (c) => {
+    const row = await resourcesService.deletePoolMember(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource pool member not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/requirements", async (c) => {
+    const query = resourceRequirementListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listRequirements(c.get("db"), query));
+})
+    .post("/requirements", async (c) => {
+    return c.json({
+        data: await resourcesService.createRequirement(c.get("db"), insertResourceRequirementSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .post("/requirements/batch-update", async (c) => {
+    const body = batchUpdateResourceRequirementSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: resourcesService.updateRequirement,
+    }));
+})
+    .post("/requirements/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: resourcesService.deleteRequirement,
+    }));
+})
+    .get("/requirements/:id", async (c) => {
+    const row = await resourcesService.getRequirementById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource requirement not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/requirements/:id", async (c) => {
+    const row = await resourcesService.updateRequirement(c.get("db"), c.req.param("id"), updateResourceRequirementSchema.parse(await c.req.json()));
+    if (!row)
+        return c.json({ error: "Resource requirement not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/requirements/:id", async (c) => {
+    const row = await resourcesService.deleteRequirement(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource requirement not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/allocations", async (c) => {
+    const query = resourceRequirementListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listRequirements(c.get("db"), query));
+})
+    .post("/allocations", async (c) => {
+    return c.json({
+        data: await resourcesService.createRequirement(c.get("db"), insertResourceRequirementSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .post("/allocations/batch-update", async (c) => {
+    const body = batchUpdateResourceRequirementSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: resourcesService.updateRequirement,
+    }));
+})
+    .post("/allocations/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: resourcesService.deleteRequirement,
+    }));
+})
+    .get("/allocations/:id", async (c) => {
+    const row = await resourcesService.getRequirementById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource allocation not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/allocations/:id", async (c) => {
+    const row = await resourcesService.updateRequirement(c.get("db"), c.req.param("id"), updateResourceRequirementSchema.parse(await c.req.json()));
+    if (!row)
+        return c.json({ error: "Resource allocation not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/allocations/:id", async (c) => {
+    const row = await resourcesService.deleteRequirement(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource allocation not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/slot-assignments", async (c) => {
+    const query = resourceSlotAssignmentListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listSlotAssignments(c.get("db"), query));
+})
+    .post("/slot-assignments", async (c) => {
+    return c.json({
+        data: await resourcesService.createSlotAssignment(c.get("db"), insertResourceSlotAssignmentSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .post("/slot-assignments/batch-update", async (c) => {
+    const body = batchUpdateResourceSlotAssignmentSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: resourcesService.updateSlotAssignment,
+    }));
+})
+    .post("/slot-assignments/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: resourcesService.deleteSlotAssignment,
+    }));
+})
+    .get("/slot-assignments/:id", async (c) => {
+    const row = await resourcesService.getSlotAssignmentById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource slot assignment not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/slot-assignments/:id", async (c) => {
+    const row = await resourcesService.updateSlotAssignment(c.get("db"), c.req.param("id"), updateResourceSlotAssignmentSchema.parse(await c.req.json()));
+    if (!row)
+        return c.json({ error: "Resource slot assignment not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/slot-assignments/:id", async (c) => {
+    const row = await resourcesService.deleteSlotAssignment(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource slot assignment not found" }, 404);
+    return c.json({ success: true });
+})
+    .get("/closeouts", async (c) => {
+    const query = resourceCloseoutListQuerySchema.parse(Object.fromEntries(new URL(c.req.url).searchParams));
+    return c.json(await resourcesService.listCloseouts(c.get("db"), query));
+})
+    .post("/closeouts", async (c) => {
+    return c.json({
+        data: await resourcesService.createCloseout(c.get("db"), insertResourceCloseoutSchema.parse(await c.req.json())),
+    }, 201);
+})
+    .post("/closeouts/batch-update", async (c) => {
+    const body = batchUpdateResourceCloseoutSchema.parse(await c.req.json());
+    return c.json(await handleBatchUpdate({
+        db: c.get("db"),
+        ids: body.ids,
+        patch: body.patch,
+        update: resourcesService.updateCloseout,
+    }));
+})
+    .post("/closeouts/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: resourcesService.deleteCloseout,
+    }));
+})
+    .get("/closeouts/:id", async (c) => {
+    const row = await resourcesService.getCloseoutById(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource closeout not found" }, 404);
+    return c.json({ data: row });
+})
+    .patch("/closeouts/:id", async (c) => {
+    const row = await resourcesService.updateCloseout(c.get("db"), c.req.param("id"), updateResourceCloseoutSchema.parse(await c.req.json()));
+    if (!row)
+        return c.json({ error: "Resource closeout not found" }, 404);
+    return c.json({ data: row });
+})
+    .delete("/closeouts/:id", async (c) => {
+    const row = await resourcesService.deleteCloseout(c.get("db"), c.req.param("id"));
+    if (!row)
+        return c.json({ error: "Resource closeout not found" }, 404);
+    return c.json({ success: true });
+});