Merge branch 'copilot/add-http-server-implementation' into copilot/update-codebase-references

Author: hotlong

content/docs/references/api/view.mdx

@@ -0,0 +1,35 @@
+---
+title: View
+description: View protocol schemas
+---
+
+# View
+
+<Callout type="info">
+**Source:** `packages/spec/src/api/view.zod.ts`
+</Callout>
+
+## TypeScript Usage
+
+```typescript
+import { HttpMethodSchema } from '@objectstack/spec/api';
+import type { HttpMethod } from '@objectstack/spec/api';
+
+// Validate data
+const result = HttpMethodSchema.parse(data);
+```
+
+---
+
+## HttpMethod
+
+### Allowed Values
+
+* `GET`
+* `POST`
+* `PUT`
+* `DELETE`
+* `PATCH`
+* `HEAD`
+* `OPTIONS`
+

examples/rest-server-example.ts

@@ -5,7 +5,7 @@
  * generate RESTful CRUD endpoints for your ObjectStack application.
  */
 
-import { RestServer, HttpServer } from '@objectstack/runtime';
+import { RestServer } from '@objectstack/runtime';
 import type { IProtocolProvider } from '@objectstack/runtime';
 
 /**

packages/runtime/src/http-server.ts

@@ -1,4 +1,4 @@
-import { IHttpServer, IHttpRequest, IHttpResponse, RouteHandler, Middleware } from '@objectstack/core';
+import { IHttpServer, RouteHandler, Middleware } from '@objectstack/core';
 
 /**
  * HttpServer - Unified HTTP Server Abstraction

packages/runtime/src/rest-server.ts

@@ -1,4 +1,4 @@
-import { IHttpServer, RouteHandler } from '@objectstack/core';
+import { IHttpServer } from '@objectstack/core';
 import { RouteManager } from './route-manager';
 import { RestServerConfig, CrudOperation, RestApiConfig, CrudEndpointsConfig, MetadataEndpointsConfig, BatchEndpointsConfig, RouteGenerationConfig } from '@objectstack/spec/api';
 import { ObjectStackProtocol } from '@objectstack/spec/api';
@@ -295,7 +295,7 @@ export class RestServer {
                             });
 
                             if (result.notModified) {
-                                res.status(304).json({});
+                                res.status(304).send();
                                 return;
                             }
 

packages/runtime/src/route-manager.ts

@@ -61,9 +61,16 @@ export class RouteManager {
      * @param entry - Route entry with method, path, handler, and metadata
      */
     register(entry: Omit<RouteEntry, 'handler'> & { handler: RouteHandler | string }): void {
-        const handler = typeof entry.handler === 'string' 
-            ? this.resolveHandler(entry.handler)
-            : entry.handler;
+        // Validate handler type - string handlers not yet supported
+        if (typeof entry.handler === 'string') {
+            throw new Error(
+                `String-based route handlers are not supported yet. ` +
+                `Received handler identifier "${entry.handler}". ` +
+                `Please provide a RouteHandler function instead.`
+            );
+        }
+        
+        const handler: RouteHandler = entry.handler;
 
         const routeEntry: RouteEntry = {
             method: entry.method,
@@ -200,13 +207,6 @@ export class RouteManager {
                 throw new Error(`Unsupported HTTP method: ${method}`);
         }
     }
-    
-    /**
-     * Resolve handler by name (placeholder for future handler registry)
-     */
-    private resolveHandler(handlerName: string): RouteHandler {
-        throw new Error(`Handler resolution not implemented: ${handlerName}`);
-    }
 }
 
 /**

packages/spec/json-schema/api/HttpMethod.json

@@ -0,0 +1,18 @@
+{
+  "$ref": "#/definitions/HttpMethod",
+  "definitions": {
+    "HttpMethod": {
+      "type": "string",
+      "enum": [
+        "GET",
+        "POST",
+        "PUT",
+        "DELETE",
+        "PATCH",
+        "HEAD",
+        "OPTIONS"
+      ]
+    }
+  },
+  "$schema": "http://json-schema.org/draft-07/schema#"
+}

packages/spec/src/api/router.zod.ts

@@ -1,6 +1,9 @@
 import { z } from 'zod';
 import { CorsConfigSchema, StaticMountSchema, HttpMethod } from '../shared/http.zod';
 
+// Re-export HttpMethod for convenience
+export { HttpMethod };
+
 /**
  * Route Category Enum
  * Classifies routes for middleware application and security policies.

packages/spec/src/data/external-lookup.test.ts

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
 import {
   ExternalDataSourceSchema,
-  FieldMappingSchema,
+  ExternalFieldMappingSchema,
   ExternalLookupSchema,
   type ExternalLookup,
   type ExternalDataSource,
-  type FieldMapping,
+  type ExternalFieldMapping,
 } from './external-lookup.zod';
 
 describe('ExternalDataSourceSchema', () => {
@@ -118,16 +118,16 @@ describe('ExternalDataSourceSchema', () => {
   });
 });
 
-describe('FieldMappingSchema', () => {
+describe('ExternalFieldMappingSchema', () => {
   it('should validate complete field mapping', () => {
-    const validMapping: FieldMapping = {
+    const validMapping: ExternalFieldMapping = {
       source: 'AccountName',
       target: 'name',
       type: 'text',
       readonly: true,
     };
 
-    expect(() => FieldMappingSchema.parse(validMapping)).not.toThrow();
+    expect(() => ExternalFieldMappingSchema.parse(validMapping)).not.toThrow();
   });
 
   it('should accept minimal field mapping', () => {
@@ -137,7 +137,7 @@ describe('FieldMappingSchema', () => {
       type: 'text',
     };
 
-    expect(() => FieldMappingSchema.parse(minimalMapping)).not.toThrow();
+    expect(() => ExternalFieldMappingSchema.parse(minimalMapping)).not.toThrow();
   });
 
   it('should default readonly to true', () => {
@@ -147,7 +147,7 @@ describe('FieldMappingSchema', () => {
       type: 'text',
     };
 
-    const parsed = FieldMappingSchema.parse(mapping);
+    const parsed = ExternalFieldMappingSchema.parse(mapping);
     expect(parsed.readonly).toBe(true);
   });
 
@@ -159,7 +159,7 @@ describe('FieldMappingSchema', () => {
       readonly: false,
     };
 
-    expect(() => FieldMappingSchema.parse(writableMapping)).not.toThrow();
+    expect(() => ExternalFieldMappingSchema.parse(writableMapping)).not.toThrow();
   });
 
   it('should accept various field types', () => {
@@ -172,7 +172,7 @@ describe('FieldMappingSchema', () => {
         type,
       };
 
-      expect(() => FieldMappingSchema.parse(mapping)).not.toThrow();
+      expect(() => ExternalFieldMappingSchema.parse(mapping)).not.toThrow();
     });
   });
 });