Merge pull request #77 from Bostads-AB-Mimer/feature/mim-572-skapa-endpoint-for-att-hamta-byggnad

MIM-572: Create endpoint to get building by code

Author: simonkropp

packages/property-base/src/adapters/building-adapter.ts

@@ -81,6 +81,29 @@ const getBuildingById = async (
     .then(trimStrings)
 }
 
+const getBuildingByCode = async (
+  code: string
+): Promise<BuildingWithRelations | null> => {
+  return prisma.building
+    .findFirst({
+      where: {
+        buildingCode: code,
+      },
+      include: {
+        buildingType: true,
+        marketArea: true,
+        propertyDesignation: true,
+        district: true,
+        propertyObject: {
+          include: {
+            property: true,
+          },
+        },
+      },
+    })
+    .then(trimStrings)
+}
+
 /**
  * Searches buildings by name
  * At the moment this function has an "under investigation" approach to fetchin
@@ -168,4 +191,4 @@ const searchBuildings = async (
   }
 }
 
-export { getBuildings, getBuildingById, searchBuildings }
+export { getBuildings, getBuildingById, getBuildingByCode, searchBuildings }

packages/property-base/src/routes/buildings-route.ts

@@ -8,12 +8,14 @@ import { logger, generateRouteMetadata } from 'onecore-utilities'
 import { z } from 'zod'
 
 import {
+  getBuildingByCode,
   getBuildingById,
   getBuildings,
   searchBuildings,
 } from '../adapters/building-adapter'
 import { buildingsQueryParamsSchema, BuildingSchema } from '../types/building'
 import { parseRequest } from '../middleware/parse-request'
+import { transformBuildingData } from '../utils/buildings'
 
 /**
  * @swagger
@@ -73,30 +75,9 @@ export const routes = (router: KoaRouter) => {
         const buildings = await getBuildings(propertyCode)
 
         const responseContent = buildings.map((building) => {
-          const parsedBuilding = BuildingSchema.parse({
-            id: building.id,
-            code: building.buildingCode,
-            name: building.name || '',
-            buildingType: {
-              id: building.buildingType?.id || '',
-              code: building.buildingType?.code || '',
-              name: building.buildingType?.name || '',
-            },
-            construction: {
-              constructionYear: building.constructionYear,
-              renovationYear: building.renovationYear,
-              valueYear: building.valueYear,
-            },
-            features: {
-              heating: building.heating || '',
-              fireRating: building.fireRating || '',
-            },
-            insurance: {
-              class: building.insuranceClass,
-              value: building.insuranceValue,
-            },
-            deleted: Boolean(building.deleteMark),
-          })
+          const parsedBuilding = BuildingSchema.parse(
+            transformBuildingData(building)
+          )
 
           return parsedBuilding
         })
@@ -202,6 +183,65 @@ export const routes = (router: KoaRouter) => {
     }
   )
 
+  /**
+   * @swagger
+   * /buildings/by-building-code/{buildingCode}:
+   *   get:
+   *     summary: Get detailed information about a specific building by building code
+   *     description: |
+   *       Retrieves comprehensive information about a building using its building code.
+   *       Returns details including construction year, renovation history, insurance information,
+   *       and associated property data.
+   *     tags:
+   *       - Buildings
+   *     parameters:
+   *       - in: path
+   *         name: buildingCode
+   *         required: true
+   *         schema:
+   *           type: string
+   *         description: The building code of the building
+   *     responses:
+   *       200:
+   *         description: Successfully retrieved building information
+   *         content:
+   *           application/json:
+   *             schema:
+   *               type: object
+   *               properties:
+   *                 content:
+   *                   $ref: '#/components/schemas/Building'
+   *       404:
+   *         description: Building not found
+   *       500:
+   *         description: Internal server error
+   */
+  router.get('(.*)/buildings/by-building-code/:buildingCode', async (ctx) => {
+    const metadata = generateRouteMetadata(ctx)
+    const buildingCode = ctx.params.buildingCode
+    logger.info(`GET /buildings/by-building-code/${buildingCode}`, metadata)
+
+    try {
+      const building = await getBuildingByCode(buildingCode)
+
+      if (!building) {
+        ctx.status = 404
+        return
+      }
+
+      const transformedData = transformBuildingData(building)
+
+      ctx.body = {
+        content: BuildingSchema.parse(transformedData),
+        ...metadata,
+      }
+    } catch (err) {
+      ctx.status = 500
+      const errorMessage = err instanceof Error ? err.message : 'unknown error'
+      ctx.body = { reason: errorMessage, ...metadata }
+    }
+  })
+
   /**
    * @swagger
    * /buildings/{id}:
@@ -249,33 +289,10 @@ export const routes = (router: KoaRouter) => {
         return
       }
 
-      const parsedBuilding = BuildingSchema.parse({
-        id: building.id,
-        code: building.buildingCode,
-        name: building.name || '',
-        buildingType: {
-          id: building.buildingType?.id || '',
-          code: building.buildingType?.code || '',
-          name: building.buildingType?.name || '',
-        },
-        construction: {
-          constructionYear: building.constructionYear,
-          renovationYear: building.renovationYear,
-          valueYear: building.valueYear,
-        },
-        features: {
-          heating: building.heating,
-          fireRating: building.fireRating,
-        },
-        insurance: {
-          class: building.insuranceClass,
-          value: building.insuranceValue,
-        },
-        deleted: Boolean(building.deleteMark),
-      })
+      const transformedData = transformBuildingData(building)
 
       ctx.body = {
-        content: parsedBuilding,
+        content: BuildingSchema.parse(transformedData),
         ...metadata,
       }
     } catch (err) {

packages/property-base/src/types/building.ts

@@ -9,11 +9,11 @@ export const buildingsQueryParamsSchema = z.object({
 export const BuildingSchema = z.object({
   id: z.string(),
   code: z.string(),
-  name: z.string(),
+  name: z.string().nullable(),
   buildingType: z.object({
-    id: z.string(),
-    code: z.string(),
-    name: z.string(),
+    id: z.string().nullable(),
+    code: z.string().nullable(),
+    name: z.string().nullable(),
   }),
   construction: z.object({
     constructionYear: z.number().nullable(),

packages/property-base/src/utils/buildings.ts

@@ -0,0 +1,43 @@
+import { BuildingWithRelations } from '@src/adapters/building-adapter'
+import { Building } from '@src/types/building'
+
+/**
+ * Transforms a building entity with relations into a normalized building data object.
+ *
+ * @param building - The building entity with all its related data
+ * @returns A transformed building object with normalized structure containing:
+ *   - Basic info (id, code, name)
+ *   - Building type details (id, code, name)
+ *   - Construction information (construction year, renovation year, value year)
+ *   - Building features (heating, fire rating)
+ *   - Insurance details (class, value)
+ *   - Deletion status
+ */
+export function transformBuildingData(
+  building: BuildingWithRelations
+): Building {
+  return {
+    id: building.id,
+    code: building.buildingCode,
+    name: building.name || null,
+    buildingType: {
+      id: building.buildingType?.id || null,
+      code: building.buildingType?.code || null,
+      name: building.buildingType?.name || null,
+    },
+    construction: {
+      constructionYear: building.constructionYear,
+      renovationYear: building.renovationYear,
+      valueYear: building.valueYear,
+    },
+    features: {
+      heating: building.heating || null,
+      fireRating: building.fireRating || null,
+    },
+    insurance: {
+      class: building.insuranceClass,
+      value: building.insuranceValue,
+    },
+    deleted: Boolean(building.deleteMark),
+  }
+}