sovrium 0.0.2

package/src/presentation/api/routes/tables/batch-routes.ts

@@ -0,0 +1,355 @@
+/**
+ * Copyright (c) 2025 ESSENTIAL SERVICES
+ *
+ * This source code is licensed under the Business Source License 1.1
+ * found in the LICENSE.md file in the root directory of this source tree.
+ */
+
+import { Effect } from 'effect'
+import {
+  hasCreatePermission,
+  hasUpdatePermission,
+  hasDeletePermission,
+} from '@/application/use-cases/tables/permissions/permissions'
+import {
+  batchCreateProgram,
+  batchUpdateProgram,
+  batchDeleteProgram,
+  batchRestoreProgram,
+  upsertProgram,
+} from '@/application/use-cases/tables/programs'
+import {
+  batchCreateRecordsRequestSchema,
+  batchUpdateRecordsRequestSchema,
+  batchDeleteRecordsRequestSchema,
+  batchRestoreRecordsRequestSchema,
+  upsertRecordsRequestSchema,
+} from '@/domain/models/api/request'
+import {
+  batchCreateRecordsResponseSchema,
+  batchUpdateRecordsResponseSchema,
+  batchDeleteRecordsResponseSchema,
+  upsertRecordsResponseSchema,
+} from '@/domain/models/api/tables'
+import { runEffect } from '@/presentation/api/utils'
+import { getTableContext } from '@/presentation/api/utils/context-helpers'
+import { validateRequest } from '@/presentation/api/utils/validate-request'
+import {
+  checkViewerPermission,
+  checkRecordLimitExceeded,
+  applyBatchReadFiltering,
+  checkBatchFieldPermissions,
+  validateStrippedRecordsNotEmpty,
+} from './batch-permission-helpers'
+import { runTableProgram, provideTableLive } from './effect-runner'
+import {
+  validateReadonlyFields,
+  validateUpsertRequest,
+  applyReadFiltering,
+  stripUnwritableFields,
+} from './upsert-helpers'
+import { handleBatchRestoreError } from './utils'
+import type { App } from '@/domain/models/app'
+import type { Context, Hono } from 'hono'
+
+/* eslint-disable drizzle/enforce-delete-with-where -- These are Hono route methods, not Drizzle queries */
+
+/**
+ * Handle batch restore endpoint
+ */
+async function handleBatchRestore(c: Context, _app: App) {
+  // Session, tableName, and userRole are guaranteed by middleware chain
+  const { session, tableName, userRole } = getTableContext(c)
+
+  // Authorization check BEFORE validation (viewer role cannot restore)
+  if (userRole === 'viewer') {
+    return c.json(
+      {
+        error: 'Forbidden',
+        message: 'You do not have permission to restore records in this table',
+      },
+      403
+    )
+  }
+
+  const result = await validateRequest(c, batchRestoreRecordsRequestSchema)
+  if (!result.success) return result.response
+
+  const programResult = await runTableProgram(
+    batchRestoreProgram(session, tableName, result.data.ids)
+  )
+
+  if (programResult._tag === 'Left') {
+    return handleBatchRestoreError(c, programResult.left)
+  }
+
+  return c.json(programResult.right, 200)
+}
+
+/**
+ * Handle batch create endpoint
+ */
+async function handleBatchCreate(c: Context, app: App) {
+  // Session, tableName, and userRole are guaranteed by middleware chain
+  const { session, tableName, userRole } = getTableContext(c)
+
+  // Authorization check BEFORE validation (viewer role cannot create)
+  const viewerCheck = checkViewerPermission(userRole, c)
+  if (viewerCheck) return viewerCheck
+
+  // Check record count before validation to return 413 for payload too large
+  const body = await c.req.json()
+  const recordLimitCheck = checkRecordLimitExceeded(body.records || [], c)
+  if (recordLimitCheck) return recordLimitCheck
+
+  const result = await validateRequest(c, batchCreateRecordsRequestSchema)
+  if (!result.success) return result.response
+
+  const table = app.tables?.find((t) => t.name === tableName)
+  if (!hasCreatePermission(table, userRole)) {
+    return c.json(
+      {
+        success: false,
+        message: 'You do not have permission to create records in this table',
+        code: 'FORBIDDEN',
+      },
+      403
+    )
+  }
+
+  // Check field-level permissions
+  const fieldPermCheck = checkBatchFieldPermissions({
+    records: result.data.records,
+    app,
+    tableName,
+    userRole,
+    c,
+  })
+  if (fieldPermCheck) return fieldPermCheck
+
+  // Validate readonly fields
+  const readonlyValidation = validateReadonlyFields(table, result.data.records, c)
+  if (readonlyValidation) return readonlyValidation
+
+  // Extract flat field objects from records for database layer
+  const flatRecordsData = result.data.records.map((record) => record.fields)
+
+  // Execute batch create with returnRecords parameter and app for numeric coercion
+  const program = batchCreateProgram({
+    session,
+    tableName,
+    recordsData: flatRecordsData,
+    returnRecords: result.data.returnRecords,
+    app,
+  })
+
+  // Apply field-level read filtering to response (if records returned)
+  const filteredProgram = program.pipe(
+    Effect.map((response) =>
+      applyBatchReadFiltering(
+        response,
+        { app, tableName, userRole, userId: session.userId },
+        'created'
+      )
+    )
+  )
+
+  return runEffect(c, provideTableLive(filteredProgram), batchCreateRecordsResponseSchema, 201)
+}
+
+/**
+ * Handle batch update endpoint
+ */
+async function handleBatchUpdate(c: Context, app: App) {
+  // Session, tableName, and userRole are guaranteed by middleware chain
+  const { session, tableName, userRole } = getTableContext(c)
+
+  // Authorization check BEFORE validation (viewer role cannot update)
+  const viewerCheck = checkViewerPermission(userRole, c)
+  if (viewerCheck) return viewerCheck
+
+  const result = await validateRequest(c, batchUpdateRecordsRequestSchema)
+  if (!result.success) return result.response
+
+  const table = app.tables?.find((t) => t.name === tableName)
+
+  // Authorization: Check table-level update permission
+  if (!hasUpdatePermission(table, userRole, app.tables)) {
+    return c.json(
+      {
+        success: false,
+        message: 'You do not have permission to update records in this table',
+        code: 'FORBIDDEN',
+      },
+      403
+    )
+  }
+
+  // Validate readonly fields BEFORE permission checks
+  const readonlyValidation = validateReadonlyFields(table, result.data.records, c)
+  if (readonlyValidation) return readonlyValidation
+
+  // Authorization: Check field-level write permissions and strip unwritable fields
+  const strippedRecords = stripUnwritableFields(app, tableName, userRole, result.data.records)
+
+  // Validate at least some writable fields remain after stripping
+  const strippedValidation = validateStrippedRecordsNotEmpty({
+    strippedRecords,
+    originalRecords: result.data.records,
+    app,
+    tableName,
+    userRole,
+    c,
+  })
+  if (strippedValidation) return strippedValidation
+
+  const recordsData = strippedRecords.map((record) => ({
+    id: record.id,
+    fields: record.fields,
+  }))
+
+  // Execute batch update with field-level read filtering on response
+  const filteredProgram = batchUpdateProgram({
+    session,
+    tableName,
+    recordsData,
+    returnRecords: result.data.returnRecords,
+    app,
+  }).pipe(
+    Effect.map((response) =>
+      applyBatchReadFiltering(
+        response,
+        { app, tableName, userRole, userId: session.userId },
+        'updated'
+      )
+    )
+  )
+
+  return runEffect(c, provideTableLive(filteredProgram), batchUpdateRecordsResponseSchema)
+}
+
+/**
+ * Handle batch delete endpoint
+ */
+async function handleBatchDelete(c: Context, app: App) {
+  // Session, tableName, and userRole are guaranteed by middleware chain
+  const { session, tableName, userRole } = getTableContext(c)
+
+  // Authorization check BEFORE validation (viewer role cannot delete)
+  const viewerCheck = checkViewerPermission(userRole, c, 'delete records in this table')
+  if (viewerCheck) return viewerCheck
+
+  // Check payload size before validation
+  const body = await c.req.json()
+  if (body.ids && body.ids.length > 1000) {
+    return c.json({ error: 'PayloadTooLarge' }, 413)
+  }
+
+  const result = await validateRequest(c, batchDeleteRecordsRequestSchema)
+  if (!result.success) return result.response
+
+  const table = app.tables?.find((t) => t.name === tableName)
+
+  // Authorization: Check table-level delete permission
+  if (!hasDeletePermission(table, userRole, app.tables)) {
+    return c.json(
+      {
+        success: false,
+        message: 'You do not have permission to delete records in this table',
+        code: 'FORBIDDEN',
+      },
+      403
+    )
+  }
+
+  // Check for permanent delete query parameter
+  const permanent = c.req.query('permanent') === 'true'
+
+  return runEffect(
+    c,
+    provideTableLive(batchDeleteProgram(session, tableName, result.data.ids, permanent)),
+    batchDeleteRecordsResponseSchema
+  )
+}
+
+/**
+ * Handle upsert endpoint
+ */
+async function handleUpsert(c: Context, app: App) {
+  const { session, tableName, userRole } = getTableContext(c)
+
+  // Authorization check BEFORE validation (viewer role cannot upsert)
+  const viewerCheck = checkViewerPermission(userRole, c)
+  if (viewerCheck) return viewerCheck
+
+  const result = await validateRequest(c, upsertRecordsRequestSchema)
+  if (!result.success) return result.response
+
+  const table = app.tables?.find((t) => t.name === tableName)
+
+  // Check for 'id' field (always readonly) with upsert-specific message
+  const hasIdField = result.data.records.some((record) => 'id' in record.fields)
+  if (hasIdField) {
+    return c.json(
+      {
+        success: false,
+        message: 'Cannot set readonly field: id',
+        code: 'VALIDATION_ERROR',
+      },
+      400
+    )
+  }
+
+  // Validate readonly fields BEFORE permission checks
+  const readonlyValidation = validateReadonlyFields(table, result.data.records, c)
+  if (readonlyValidation) return readonlyValidation
+
+  // Validate permissions and required fields
+  const validation = await validateUpsertRequest({
+    c,
+    app,
+    tableName,
+    userRole,
+    records: result.data.records,
+    fieldsToMergeOn: result.data.fieldsToMergeOn,
+  })
+  if (!validation.success) return validation.response
+
+  // Extract flat field objects for database layer
+  const flatRecordsData = validation.strippedRecords.map((record) => record.fields)
+
+  // Execute upsert
+  const program = upsertProgram(session, tableName, {
+    recordsData: flatRecordsData,
+    fieldsToMergeOn: result.data.fieldsToMergeOn,
+    returnRecords: result.data.returnRecords,
+    app,
+  })
+
+  // Apply field-level read filtering to response
+  const filteredProgram = applyReadFiltering({
+    program,
+    app,
+    tableName,
+    userRole,
+    userId: session.userId,
+  })
+
+  return runEffect(c, provideTableLive(filteredProgram), upsertRecordsResponseSchema)
+}
+
+export function chainBatchRoutesMethods<T extends Hono>(honoApp: T, app: App) {
+  return (
+    honoApp
+      // IMPORTANT: More specific routes (batch/restore, batch/delete) must come BEFORE generic batch routes
+      .post('/api/tables/:tableId/records/batch/restore', (c) => handleBatchRestore(c, app))
+      .post('/api/tables/:tableId/records/batch/delete', (c) => handleBatchDelete(c, app))
+      // Generic batch routes AFTER more specific batch/restore and batch/delete routes
+      .post('/api/tables/:tableId/records/batch', (c) => handleBatchCreate(c, app))
+      .patch('/api/tables/:tableId/records/batch', (c) => handleBatchUpdate(c, app))
+      .delete('/api/tables/:tableId/records/batch', (c) => handleBatchDelete(c, app))
+      .post('/api/tables/:tableId/records/upsert', (c) => handleUpsert(c, app))
+  )
+}
+
+/* eslint-enable drizzle/enforce-delete-with-where */