sovrium 0.0.2 → 0.2.0

package/src/infrastructure/server/route-setup/openapi-routes/table-routes.ts

@@ -0,0 +1,100 @@
+/**
+ * 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 { type OpenAPIHono, createRoute } from '@hono/zod-openapi'
+import { errorResponseSchema } from '@/domain/models/api/error'
+import { tableIdParamSchema } from '@/domain/models/api/params'
+import {
+  getTablePermissionsResponseSchema,
+  getTableResponseSchema,
+  listTablesResponseSchema,
+} from '@/domain/models/api/tables'
+
+/**
+ * Register table management routes for OpenAPI schema generation
+ */
+export function registerTableRoutes(app: OpenAPIHono): void {
+  // GET /api/tables
+  app.openapi(
+    createRoute({
+      method: 'get',
+      path: '/api/tables',
+      summary: 'List all tables',
+      description: 'Returns a list of all tables with summary information.',
+      operationId: 'listTables',
+      tags: ['tables'],
+      responses: {
+        200: {
+          content: { 'application/json': { schema: listTablesResponseSchema } },
+          description: 'List of tables',
+        },
+        401: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Unauthorized',
+        },
+      },
+    }),
+    (c) => c.json({} as never)
+  )
+
+  // GET /api/tables/{tableId}
+  app.openapi(
+    createRoute({
+      method: 'get',
+      path: '/api/tables/{tableId}',
+      summary: 'Get table details',
+      description: 'Returns full table definition including fields, views, and permissions.',
+      operationId: 'getTable',
+      tags: ['tables'],
+      request: { params: tableIdParamSchema },
+      responses: {
+        200: {
+          content: { 'application/json': { schema: getTableResponseSchema } },
+          description: 'Table details',
+        },
+        401: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Unauthorized',
+        },
+        404: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Table not found',
+        },
+      },
+    }),
+    (c) => c.json({} as never)
+  )
+
+  // GET /api/tables/{tableId}/permissions
+  app.openapi(
+    createRoute({
+      method: 'get',
+      path: '/api/tables/{tableId}/permissions',
+      summary: 'Get table permissions',
+      description:
+        "Returns the current user's permissions for the table, including field-level access.",
+      operationId: 'getTablePermissions',
+      tags: ['tables'],
+      request: { params: tableIdParamSchema },
+      responses: {
+        200: {
+          content: { 'application/json': { schema: getTablePermissionsResponseSchema } },
+          description: 'Table permissions',
+        },
+        401: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Unauthorized',
+        },
+        404: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Table not found',
+        },
+      },
+    }),
+    (c) => c.json({} as never)
+  )
+}

package/src/infrastructure/server/route-setup/openapi-routes/view-routes.ts

@@ -0,0 +1,104 @@
+/**
+ * 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 { type OpenAPIHono, createRoute } from '@hono/zod-openapi'
+import { errorResponseSchema } from '@/domain/models/api/error'
+import { tableIdParamSchema, viewIdParamSchema } from '@/domain/models/api/params'
+import {
+  getViewRecordsResponseSchema,
+  getViewResponseSchema,
+  listViewsResponseSchema,
+} from '@/domain/models/api/tables'
+
+/**
+ * Register view routes for OpenAPI schema generation
+ */
+export function registerViewRoutes(app: OpenAPIHono): void {
+  // GET /api/tables/{tableId}/views
+  app.openapi(
+    createRoute({
+      method: 'get',
+      path: '/api/tables/{tableId}/views',
+      summary: 'List views',
+      description: 'Returns all views defined for a table.',
+      operationId: 'listViews',
+      tags: ['views'],
+      request: { params: tableIdParamSchema },
+      responses: {
+        200: {
+          content: { 'application/json': { schema: listViewsResponseSchema } },
+          description: 'List of views',
+        },
+        401: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Unauthorized',
+        },
+        404: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Table not found',
+        },
+      },
+    }),
+    (c) => c.json({} as never)
+  )
+
+  // GET /api/tables/{tableId}/views/{viewId}
+  app.openapi(
+    createRoute({
+      method: 'get',
+      path: '/api/tables/{tableId}/views/{viewId}',
+      summary: 'Get view details',
+      description: 'Returns view configuration including filters, sorts, and visible fields.',
+      operationId: 'getView',
+      tags: ['views'],
+      request: { params: viewIdParamSchema },
+      responses: {
+        200: {
+          content: { 'application/json': { schema: getViewResponseSchema } },
+          description: 'View details',
+        },
+        401: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Unauthorized',
+        },
+        404: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'View not found',
+        },
+      },
+    }),
+    (c) => c.json({} as never)
+  )
+
+  // GET /api/tables/{tableId}/views/{viewId}/records
+  app.openapi(
+    createRoute({
+      method: 'get',
+      path: '/api/tables/{tableId}/views/{viewId}/records',
+      summary: 'Get records through a view',
+      description: 'Returns records filtered and sorted according to the view configuration.',
+      operationId: 'getViewRecords',
+      tags: ['views'],
+      request: { params: viewIdParamSchema },
+      responses: {
+        200: {
+          content: { 'application/json': { schema: getViewRecordsResponseSchema } },
+          description: 'Filtered records',
+        },
+        401: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'Unauthorized',
+        },
+        404: {
+          content: { 'application/json': { schema: errorResponseSchema } },
+          description: 'View not found',
+        },
+      },
+    }),
+    (c) => c.json({} as never)
+  )
+}

package/src/infrastructure/server/route-setup/openapi-schema.ts

@@ -5,8 +5,17 @@
  * found in the LICENSE.md file in the root directory of this source tree.
  */
 
-import { OpenAPIHono, createRoute } from '@hono/zod-openapi'
-import { healthResponseSchema } from '@/domain/models/api/health'
+import { OpenAPIHono } from '@hono/zod-openapi'
+import { registerActivityRoutes } from './openapi-routes/activity-routes'
+import { registerAnalyticsRoutes } from './openapi-routes/analytics-routes'
+import { registerBatchRoutes } from './openapi-routes/batch-routes'
+import { registerHealthRoutes } from './openapi-routes/health-routes'
+import { registerRecordRoutes } from './openapi-routes/record-routes'
+import { registerTableRoutes } from './openapi-routes/table-routes'
+import { registerViewRoutes } from './openapi-routes/view-routes'
+
+// Read version from package.json at module load (avoids JSON import lint issues)
+const { version: APP_VERSION } = await Bun.file('package.json').json()
 
 /**
  * OpenAPI Schema Generator
@@ -25,7 +34,7 @@ import { healthResponseSchema } from '@/domain/models/api/health'
  * **Usage**:
  * 1. Runtime: Server uses regular Hono routes from api-routes.ts
  * 2. Docs: Server exposes this schema at `/api/openapi.json` and `/api/scalar`
- * 3. Export: Script exports this schema to `schemas/0.0.1/app.openapi.json`
+ * 3. Export: Script exports this schema to `schemas/{version}/app.openapi.json`
  */
 
 /**
@@ -38,42 +47,13 @@ import { healthResponseSchema } from '@/domain/models/api/health'
 const createOpenApiApp = () => {
   const app = new OpenAPIHono()
 
-  // Define health check route with OpenAPI annotations
-  const healthRoute = createRoute({
-    method: 'get',
-    path: '/api/health',
-    summary: 'Health check endpoint',
-    description:
-      'Returns server health status. Used by monitoring tools and E2E tests to verify server is running.',
-    operationId: 'healthCheck',
-    tags: ['infrastructure'],
-    responses: {
-      200: {
-        content: {
-          'application/json': {
-            schema: healthResponseSchema,
-          },
-        },
-        description: 'Server is healthy',
-      },
-    },
-  })
-
-  // Mount route with dummy handler (only for schema generation)
-
-  app.openapi(healthRoute, (c) => {
-    return c.json({
-      status: 'ok',
-      timestamp: new Date().toISOString(),
-      app: {
-        name: 'Sovrium',
-      },
-    })
-  })
-
-  // Future routes will be added here:
-  // app.openapi(listTablesRoute, ...)
-  // app.openapi(getTableRoute, ...)
+  registerHealthRoutes(app)
+  registerTableRoutes(app)
+  registerRecordRoutes(app)
+  registerBatchRoutes(app)
+  registerViewRoutes(app)
+  registerActivityRoutes(app)
+  registerAnalyticsRoutes(app)
 
   return app
 }
@@ -96,7 +76,7 @@ export const getOpenAPIDocument = () => {
     openapi: '3.1.0',
     info: {
       title: 'Sovrium API',
-      version: '0.0.1',
+      version: APP_VERSION as string,
       description:
         'REST API specification for Sovrium application.\n\n' +
         '**Generated Schema**: This schema is automatically generated from the runtime implementation. ' +
@@ -115,6 +95,26 @@ export const getOpenAPIDocument = () => {
         name: 'infrastructure',
         description: 'Infrastructure endpoints (health, metrics)',
       },
+      {
+        name: 'tables',
+        description: 'Table management endpoints',
+      },
+      {
+        name: 'records',
+        description: 'Record CRUD, comments, and history endpoints',
+      },
+      {
+        name: 'views',
+        description: 'View management and filtered record access',
+      },
+      {
+        name: 'activity',
+        description: 'Activity log and audit trail endpoints',
+      },
+      {
+        name: 'analytics',
+        description: 'Analytics collection and reporting endpoints',
+      },
     ],
   })
 }

package/src/presentation/styling/parse-style.ts

@@ -196,18 +196,26 @@ export function parseStyle(styleString: string): Record<string, string> {
 
   // Use reduce for immutable accumulation instead of for-of loop with mutations
   return declarations.reduce<Record<string, string>>((acc, declaration) => {
-    const [property, value] = declaration.split(':').map((s) => s.trim())
-    if (property && value) {
-      // Convert kebab-case to camelCase (e.g., background-color → backgroundColor)
-      const camelCaseProperty = property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
+    const colonIndex = declaration.indexOf(':')
+    if (colonIndex === -1) return acc
 
-      // Normalize animation names to kebab-case
-      const normalizedValue =
-        camelCaseProperty === 'animation' ? normalizeAnimationValue(value) : value
+    const property = declaration.slice(0, colonIndex).trim()
+    const value = declaration.slice(colonIndex + 1).trim()
+    if (!property || !value) return acc
 
-      return { ...acc, [camelCaseProperty]: normalizedValue }
+    // CSS custom properties (--*) must be preserved as-is, not converted to camelCase
+    if (property.startsWith('--')) {
+      return { ...acc, [property]: value }
     }
-    return acc
+
+    // Convert kebab-case to camelCase (e.g., background-color → backgroundColor)
+    const camelCaseProperty = property.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())
+
+    // Normalize animation names to kebab-case
+    const normalizedValue =
+      camelCaseProperty === 'animation' ? normalizeAnimationValue(value) : value
+
+    return { ...acc, [camelCaseProperty]: normalizedValue }
   }, {})
 }