feat: Add version, objects, and apis properties to App schema

- Updated App.mdx to include version, objects, and apis properties in the schema reference.
- Modified App.json to define version, objects, and apis properties in the JSON schema.
- Enhanced app.zod.ts to validate version property and make it optional.
- Introduced new ApiCapabilities and ApiRoutes schema references with their respective properties.
- Created Discovery schema reference with properties for name, version, environment, routes, features, and locale.
- Added example server implementation with dynamic schema loading and unified API routes.
- Updated package.json and tsconfig.json for the example server setup.
- Implemented DataEngine and SchemaRegistry classes for managing data and schema registration.

Author: hotlong

content/docs/references/system/ApiCapabilities.mdx

@@ -0,0 +1,13 @@
+---
+title: ApiCapabilities
+description: ApiCapabilities Schema Reference
+---
+
+## Properties
+
+| Property | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **graphql** | `boolean` | optional |  |
+| **search** | `boolean` | optional |  |
+| **websockets** | `boolean` | optional |  |
+| **files** | `boolean` | optional |  |

content/docs/references/system/ApiRoutes.mdx

@@ -0,0 +1,15 @@
+---
+title: ApiRoutes
+description: ApiRoutes Schema Reference
+---
+
+## Properties
+
+| Property | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **data** | `string` | ✅ | e.g. /api/v1/data |
+| **metadata** | `string` | ✅ | e.g. /api/v1/meta |
+| **auth** | `string` | ✅ | e.g. /api/v1/auth |
+| **actions** | `string` | optional | e.g. /api/v1/p |
+| **storage** | `string` | optional | e.g. /api/v1/storage |
+| **graphql** | `string` | optional | e.g. /api/v1/graphql |

content/docs/references/system/Discovery.mdx

@@ -0,0 +1,15 @@
+---
+title: Discovery
+description: Discovery Schema Reference
+---
+
+## Properties
+
+| Property | Type | Required | Description |
+| :--- | :--- | :--- | :--- |
+| **name** | `string` | ✅ |  |
+| **version** | `string` | ✅ |  |
+| **environment** | `Enum<'production' \| 'sandbox' \| 'development'>` | ✅ |  |
+| **routes** | `object` | ✅ |  |
+| **features** | `object` | ✅ |  |
+| **locale** | `object` | ✅ |  |

content/docs/references/ui/app/App.mdx

@@ -9,11 +9,15 @@ description: App Schema Reference
 | :--- | :--- | :--- | :--- |
 | **name** | `string` | ✅ | App unique machine name |
 | **label** | `string` | ✅ | App display label |
+| **version** | `string` | optional | App version |
 | **description** | `string` | optional | App description |
 | **icon** | `string` | optional | App icon used in the App Launcher |
 | **branding** | `object` | optional | App-specific branding |
 | **active** | `boolean` | optional | Whether the app is enabled |
 | **isDefault** | `boolean` | optional | Is default app |
-| **navigation** | `object \| object \| object \| object \| object[]` | ✅ | Structured navigation menu tree |
+| **navigation** | `object \| object \| object \| object \| object[]` | optional | Structured navigation menu tree |
+| **menus** | `any[]` | optional | Deprecated: Use navigation instead |
 | **homePageId** | `string` | optional | ID of the navigation item to serve as landing page |
 | **requiredPermissions** | `string[]` | optional | Permissions required to access this app |
+| **objects** | `any[]` | optional | Objects belonging to this app |
+| **apis** | `any[]` | optional | Custom APIs belonging to this app |

examples/server/README.md

@@ -0,0 +1,42 @@
+# ObjectStack Example Server
+
+This is a reference implementation of the ObjectStack Server Protocol (Kernel).
+It demonstrates how to build a metadata-driven backend that dynamically loads object definitions from plugins and automatically generates REST APIs.
+
+## Features
+
+- **Dynamic Schema Loading**: Loads `crm` and `todo` apps as plugins.
+- **Unified Metadata API**: `/api/v1/meta/objects`
+- **Unified Data API**: `/api/v1/data/:object` (CRUD)
+- **Zero-Code Backend**: No creating routes or controllers per object.
+
+## Setup
+
+1. Make sure all dependencies are installed in the workspace root:
+   ```bash
+   pnpm install
+   ```
+
+2. Run the server:
+   ```bash
+   npm run dev
+   ```
+
+## API Usage Examples
+
+### 1. Get All Objects
+```bash
+curl http://localhost:3000/api/v1/meta/objects
+```
+
+### 2. Create a Todo
+```bash
+curl -X POST http://localhost:3000/api/v1/data/todo_task \
+  -H "Content-Type: application/json" \
+  -d '{"title": "Buy Milk", "priority": "high"}'
+```
+
+### 3. List Todos
+```bash
+curl http://localhost:3000/api/v1/data/todo_task
+```

examples/server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@objectstack/example-server",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@objectstack/spec": "workspace:*",
+    "@objectstack/example-crm": "workspace:*",
+    "@objectstack/example-todo": "workspace:*",
+    "hono": "^4.0.0",
+    "@hono/node-server": "^1.0.0",
+    "zod": "^3.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "ts-node": "^10.0.0",
+    "@types/node": "^20.0.0"
+  }
+}

examples/server/src/index.ts

@@ -0,0 +1,129 @@
+import { serve } from '@hono/node-server';
+import { Hono } from 'hono';
+import { logger } from 'hono/logger';
+import { cors } from 'hono/cors';
+import { loadPlugins } from './loader';
+import { SchemaRegistry } from './kernel/registry';
+import { DataEngine } from './kernel/engine';
+
+// 1. Initialize Kernel
+const app = new Hono();
+const dataEngine = new DataEngine();
+
+app.use('*', logger());
+app.use('*', cors());
+
+// 2. Load Plugins (CRM, Todo)
+console.log('--- Starting ObjectStack Server ---');
+loadPlugins();
+console.log('--- Plugins Loaded ---');
+
+// 3. Define Unified Routes
+
+/**
+ * Metadata API: Get All Objects
+ */
+app.get('/api/v1/meta/objects', (c) => {
+  const objects = SchemaRegistry.getAll().map(obj => ({
+    name: obj.name,
+    label: obj.label,
+    icon: obj.icon,
+    path: `/api/v1/data/${obj.name}`
+  }));
+  return c.json({ data: objects });
+});
+
+/**
+ * Metadata API: Get Single Object
+ */
+app.get('/api/v1/meta/objects/:name', (c) => {
+  const name = c.req.param('name');
+  const schema = SchemaRegistry.get(name);
+  if (!schema) return c.json({ error: 'Not found' }, 404);
+  return c.json(schema);
+});
+
+/**
+ * Data API: Find
+ */
+app.get('/api/v1/data/:object', async (c) => {
+  const objectName = c.req.param('object');
+  const query = c.req.query();
+  
+  try {
+    const result = await dataEngine.find(objectName, query);
+    return c.json(result);
+  } catch (e: any) {
+    return c.json({ error: e.message }, 400);
+  }
+});
+
+/**
+ * Data API: Get
+ */
+app.get('/api/v1/data/:object/:id', async (c) => {
+  const objectName = c.req.param('object');
+  const id = c.req.param('id');
+  
+  try {
+    const result = await dataEngine.get(objectName, id);
+    return c.json(result);
+  } catch (e: any) {
+    return c.json({ error: e.message }, 404);
+  }
+});
+
+/**
+ * Data API: Create
+ */
+app.post('/api/v1/data/:object', async (c) => {
+  const objectName = c.req.param('object');
+  const body = await c.req.json();
+  
+  try {
+    const result = await dataEngine.create(objectName, body);
+    return c.json(result, 201);
+  } catch (e: any) {
+    return c.json({ error: e.message }, 400);
+  }
+});
+
+/**
+ * Data API: Update
+ */
+app.patch('/api/v1/data/:object/:id', async (c) => {
+  const objectName = c.req.param('object');
+  const id = c.req.param('id');
+  const body = await c.req.json();
+  
+  try {
+    const result = await dataEngine.update(objectName, id, body);
+    return c.json(result);
+  } catch (e: any) {
+    return c.json({ error: e.message }, 400);
+  }
+});
+
+/**
+ * Data API: Delete
+ */
+app.delete('/api/v1/data/:object/:id', async (c) => {
+  const objectName = c.req.param('object');
+  const id = c.req.param('id');
+  
+  try {
+    const result = await dataEngine.delete(objectName, id);
+    return c.json(result);
+  } catch (e: any) {
+    return c.json({ error: e.message }, 400);
+  }
+});
+
+// 4. Start Server
+const port = 3000;
+console.log(`Server is running on http://localhost:${port}`);
+
+serve({
+  fetch: app.fetch,
+  port
+});

examples/server/src/kernel/engine.ts

@@ -0,0 +1,72 @@
+import { ServiceObject } from '@objectstack/spec';
+import { SchemaRegistry } from './registry';
+
+// Simple in-memory storage for demonstration
+const MEMORY_DB: Record<string, any[]> = {};
+
+export class DataEngine {
+  
+  async find(objectName: string, query: any) {
+    this.ensureSchema(objectName);
+    const records = MEMORY_DB[objectName] || [];
+    // In real world: Implement parsing of `query` (filter, sort, page)
+    return {
+      value: records,
+      count: records.length
+    };
+  }
+
+  async get(objectName: string, id: string) {
+    this.ensureSchema(objectName);
+    const records = MEMORY_DB[objectName] || [];
+    const record = records.find(r => r._id === id);
+    if (!record) throw new Error(`Record not found: ${id}`);
+    return record;
+  }
+
+  async create(objectName: string, payload: any) {
+    const schema = this.ensureSchema(objectName);
+    
+    // Auto-generate ID and Timestamps
+    const record = {
+      _id: Math.random().toString(36).substring(7),
+      created_at: new Date().toISOString(),
+      ...payload
+    };
+
+    // TODO: Validate against schema.fields
+    
+    if (!MEMORY_DB[objectName]) MEMORY_DB[objectName] = [];
+    MEMORY_DB[objectName].push(record);
+    
+    return record;
+  }
+
+  async update(objectName: string, id: string, payload: any) {
+    this.ensureSchema(objectName);
+    const records = MEMORY_DB[objectName] || [];
+    const index = records.findIndex(r => r._id === id);
+    
+    if (index === -1) throw new Error(`Record not found: ${id}`);
+    
+    records[index] = { ...records[index], ...payload, updated_at: new Date().toISOString() };
+    return records[index];
+  }
+
+  async delete(objectName: string, id: string) {
+    this.ensureSchema(objectName);
+    const records = MEMORY_DB[objectName] || [];
+    const index = records.findIndex(r => r._id === id);
+    
+    if (index === -1) throw new Error(`Record not found: ${id}`);
+    
+    records.splice(index, 1);
+    return { success: true };
+  }
+
+  private ensureSchema(name: string): ServiceObject {
+    const schema = SchemaRegistry.get(name);
+    if (!schema) throw new Error(`Unknown object: ${name}`);
+    return schema;
+  }
+}

examples/server/src/kernel/registry.ts

@@ -0,0 +1,24 @@
+import { ServiceObject } from '@objectstack/spec';
+
+/**
+ * Global Schema Registry
+ */
+export class SchemaRegistry {
+  private static objects = new Map<string, ServiceObject>();
+
+  static register(schema: ServiceObject) {
+    if (this.objects.has(schema.name)) {
+      console.warn(`[Registry] Overwriting object: ${schema.name}`);
+    }
+    this.objects.set(schema.name, schema);
+    console.log(`[Registry] Registered object: ${schema.name}`);
+  }
+
+  static get(name: string): ServiceObject | undefined {
+    return this.objects.get(name);
+  }
+
+  static getAll(): ServiceObject[] {
+    return Array.from(this.objects.values());
+  }
+}

examples/server/src/loader.ts

@@ -0,0 +1,27 @@
+import { SchemaRegistry } from './kernel/registry';
+
+// In a real monorepo scenario, we might use path aliases or require.resolve
+// Here we use relative paths to demonstrate loading from the sibling packages
+// @ts-ignore
+import CrmApp from '../../crm/objectstack.config'; 
+// @ts-ignore
+import TodoApp from '../../todo/objectstack.config';
+
+export function loadPlugins() {
+  const apps = [CrmApp, TodoApp];
+
+  for (const app of apps) {
+    if (!app) continue;
+    
+    console.log(`[Loader] Loading App: ${app.name} (${app.label})`);
+    
+    // 1. Register Objects
+    if (app.objects) {
+      app.objects.forEach((obj: any) => {
+         SchemaRegistry.register(obj);
+      });
+    }
+    
+    console.log(`[Loader] Loaded ${app.objects?.length || 0} objects from ${app.name}`);
+  }
+}