@quatrain/api-server-express 1.1.6

package/README.md

@@ -0,0 +1,13 @@
+# @quatrain/api-server-express
+
+The `@quatrain/api-server-express` package provides the backend REST layer for Quatrain, exposing the underlying DataObjects and Backend engines through HTTP endpoints.
+
+## Features
+- **Express Adapter**: A lightweight wrapper around Express to bootstrap APIs instantly.
+- **Auto-generated Endpoints**: Pre-built `CrudEndpoint` and `ListEndpoint` handlers to instantly expose a Quatrain model (e.g. `StudioProperty`, `StudioModel`) as a complete REST API.
+- **Middleware Support**: Pluggable Express middlewares.
+
+---
+## Getting Started
+
+Refer to the `HOWTO.md` file for usage examples.

package/dist/adapters/ExpressAdapter.d.ts

@@ -0,0 +1,28 @@
+import express from 'express';
+import { ServerAdapter, ApiHandler, EndpointHandler, EndpointOptions } from '@quatrain/api';
+export declare class ExpressAdapter implements ServerAdapter {
+    private appOrRouter;
+    private config;
+    constructor(appOrRouter?: express.Application | express.Router, config?: {
+        apiPrefix?: string;
+    });
+    private wrapHandler;
+    get(path: string, handler: ApiHandler): void;
+    post(path: string, handler: ApiHandler): void;
+    put(path: string, handler: ApiHandler): void;
+    delete(path: string, handler: ApiHandler): void;
+    use(middleware: any): void;
+    createRouter(path: string): ServerAdapter;
+    start(port: number, callback?: () => void): void;
+    getNativeInstance(): any;
+    /**
+     * Configures the server to serve static files from a specified folder.
+     * It also sets up a fallback route for SPA (Single Page Application) navigation,
+     * ensuring that non-API routes return the main index.html file.
+     *
+     * @param folderPath The absolute path to the directory containing static files (e.g. built frontend).
+     * @param apiPrefix The prefix used for API routes, which will be ignored by the SPA fallback. Defaults to '/api'.
+     */
+    serveStatic(folderPath: string, apiPrefix?: string): void;
+    addEndpoint(handler: EndpointHandler, endpointRoot: string, options?: EndpointOptions): void;
+}

package/dist/adapters/ExpressAdapter.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapter = void 0;
+const express_1 = __importDefault(require("express"));
+class ExpressAdapter {
+    appOrRouter;
+    config;
+    constructor(appOrRouter = (0, express_1.default)(), config = {}) {
+        this.appOrRouter = appOrRouter;
+        this.config = config;
+        if ('listen' in this.appOrRouter && typeof this.appOrRouter.listen === 'function') {
+            // Default global middlewares for top-level application
+            this.appOrRouter.disable('x-powered-by');
+            this.appOrRouter.use(express_1.default.json());
+            this.appOrRouter.use((req, res, next) => {
+                res.header('Access-Control-Allow-Origin', '*');
+                res.header('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, OPTIONS');
+                res.header('Access-Control-Allow-Headers', '*');
+                if (req.method === 'OPTIONS') {
+                    return res.sendStatus(200);
+                }
+                next();
+            });
+        }
+    }
+    wrapHandler(handler) {
+        return async (req, res, next) => {
+            try {
+                const apiReq = {
+                    body: req.body,
+                    params: req.params,
+                    query: req.query
+                };
+                const apiRes = {
+                    status: (code) => {
+                        res.status(code);
+                        return apiRes;
+                    },
+                    json: (data) => {
+                        res.json(data);
+                    },
+                    send: (data) => {
+                        res.send(data);
+                    },
+                    setHeader: (name, value) => {
+                        res.setHeader(name, value);
+                    },
+                    write: (data) => {
+                        res.write(data);
+                    },
+                    end: () => {
+                        res.end();
+                    }
+                };
+                await handler(apiReq, apiRes);
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+    }
+    get(path, handler) {
+        this.appOrRouter.get(path, this.wrapHandler(handler));
+    }
+    post(path, handler) {
+        this.appOrRouter.post(path, this.wrapHandler(handler));
+    }
+    put(path, handler) {
+        this.appOrRouter.put(path, this.wrapHandler(handler));
+    }
+    delete(path, handler) {
+        this.appOrRouter.delete(path, this.wrapHandler(handler));
+    }
+    use(middleware) {
+        this.appOrRouter.use(middleware);
+    }
+    createRouter(path) {
+        const router = express_1.default.Router();
+        this.appOrRouter.use(path, router);
+        return new ExpressAdapter(router);
+    }
+    start(port, callback) {
+        if ('listen' in this.appOrRouter && typeof this.appOrRouter.listen === 'function') {
+            this.appOrRouter.listen(port, callback);
+        }
+        else {
+            throw new Error("Cannot start a server on a Router instance.");
+        }
+    }
+    getNativeInstance() {
+        return this.appOrRouter;
+    }
+    /**
+     * Configures the server to serve static files from a specified folder.
+     * It also sets up a fallback route for SPA (Single Page Application) navigation,
+     * ensuring that non-API routes return the main index.html file.
+     *
+     * @param folderPath The absolute path to the directory containing static files (e.g. built frontend).
+     * @param apiPrefix The prefix used for API routes, which will be ignored by the SPA fallback. Defaults to '/api'.
+     */
+    serveStatic(folderPath, apiPrefix = '/api') {
+        const path = require('node:path');
+        this.use(express_1.default.static(folderPath));
+        this.appOrRouter.get('*', (req, res, next) => {
+            if (req.path.startsWith(apiPrefix))
+                return next();
+            res.sendFile(path.join(folderPath, 'index.html'));
+        });
+    }
+    addEndpoint(handler, endpointRoot, options = {}) {
+        const fullPath = this.config.apiPrefix ? `${this.config.apiPrefix}${endpointRoot}` : endpointRoot;
+        const router = this.createRouter(fullPath);
+        if (options.middlewares && options.middlewares.length > 0) {
+            options.middlewares.forEach((mw) => router.use(mw));
+        }
+        handler(router, '/', options);
+    }
+}
+exports.ExpressAdapter = ExpressAdapter;

package/dist/endpoints/CrudEndpoint.d.ts

@@ -0,0 +1,3 @@
+import { EndpointHandler } from '@quatrain/api';
+import { BaseObject } from '@quatrain/core';
+export declare const CrudEndpoint: (ModelClass: typeof BaseObject) => EndpointHandler;

package/dist/endpoints/CrudEndpoint.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CrudEndpoint = void 0;
+const backend_1 = require("@quatrain/backend");
+const CrudEndpoint = (ModelClass) => {
+    return (router, path, options) => {
+        const methods = options.methods || ['CREATE', 'READ', 'UPDATE', 'DELETE'];
+        // C: Create
+        if (methods.includes('CREATE')) {
+            router.post(path, async (req, res) => {
+                try {
+                    const data = req.body;
+                    const newObj = await ModelClass.factory();
+                    Object.keys(data).forEach((key) => {
+                        if (newObj.has(key)) {
+                            newObj.set(key, data[key]);
+                        }
+                    });
+                    newObj.validate();
+                    await newObj.save();
+                    res.status(201).json(newObj.dataObject.toJSON());
+                }
+                catch (e) {
+                    if (e.name === 'ValidationError') {
+                        res.status(400).json({ error: e.message, validationErrors: e.errors });
+                    }
+                    else {
+                        backend_1.Backend.error(`[API Error] POST: ${e.message}`);
+                        res.status(400).json({ error: e.message });
+                    }
+                }
+            });
+        }
+        // R: Read (Single by ID)
+        if (methods.includes('READ')) {
+            const getPath = path.endsWith('/') ? `${path}:id` : `${path}/:id`;
+            router.get(getPath, async (req, res) => {
+                try {
+                    const obj = await ModelClass.fromBackend(req.params.id);
+                    if (!obj) {
+                        return res.status(404).json({ error: 'Object not found' });
+                    }
+                    res.json(obj.dataObject.toJSON());
+                }
+                catch (e) {
+                    backend_1.Backend.error(`[API Error] GET /${req.params.id}: ${e.message}`);
+                    res.status(500).json({ error: e.message });
+                }
+            });
+        }
+        // U: Update
+        if (methods.includes('UPDATE')) {
+            const putPath = path.endsWith('/') ? `${path}:id` : `${path}/:id`;
+            router.put(putPath, async (req, res) => {
+                try {
+                    const data = req.body;
+                    const obj = await ModelClass.fromBackend(req.params.id);
+                    if (!obj) {
+                        return res.status(404).json({ error: 'Object not found' });
+                    }
+                    Object.keys(data).forEach((key) => {
+                        if (obj.has(key)) {
+                            obj.set(key, data[key]);
+                        }
+                    });
+                    obj.validate();
+                    await obj.save();
+                    res.json(obj.dataObject.toJSON());
+                }
+                catch (e) {
+                    if (e.name === 'ValidationError') {
+                        res.status(400).json({ error: e.message, validationErrors: e.errors });
+                    }
+                    else {
+                        backend_1.Backend.error(`[API Error] PUT /${req.params.id}: ${e.message}`);
+                        res.status(400).json({ error: e.message });
+                    }
+                }
+            });
+        }
+        // D: Delete
+        if (methods.includes('DELETE')) {
+            const deletePath = path.endsWith('/') ? `${path}:id` : `${path}/:id`;
+            router.delete(deletePath, async (req, res) => {
+                try {
+                    const obj = await ModelClass.fromBackend(req.params.id);
+                    if (!obj) {
+                        return res.status(404).json({ error: 'Object not found' });
+                    }
+                    await obj.delete();
+                    res.json({ success: true });
+                }
+                catch (e) {
+                    backend_1.Backend.error(`[API Error] DELETE /${req.params.id}: ${e.message}`);
+                    res.status(500).json({ error: e.message });
+                }
+            });
+        }
+    };
+};
+exports.CrudEndpoint = CrudEndpoint;

package/dist/endpoints/ListEndpoint.d.ts

@@ -0,0 +1,3 @@
+import { EndpointHandler } from '@quatrain/api';
+import { BaseObject } from '@quatrain/core';
+export declare const ListEndpoint: (ModelClass: typeof BaseObject) => EndpointHandler;

package/dist/endpoints/ListEndpoint.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListEndpoint = void 0;
+const backend_1 = require("@quatrain/backend");
+const ListEndpoint = (ModelClass) => {
+    return (router, path, options) => {
+        router.get(path, async (req, res) => {
+            try {
+                let q = ModelClass.query();
+                // Apply all query parameters as exact match filters
+                for (const [key, value] of Object.entries(req.query)) {
+                    q = q.where(key, value, 'equals');
+                }
+                const results = await q.execute('dataObjects');
+                res.json({
+                    items: results.items.map((r) => r.toJSON()),
+                    meta: results.meta
+                });
+            }
+            catch (e) {
+                backend_1.Backend.error(`[API Error] GET (List): ${e.message}`);
+                res.status(500).json({ error: e.message });
+            }
+        });
+    };
+};
+exports.ListEndpoint = ListEndpoint;

package/dist/endpoints/ValuesEndpoint.d.ts

@@ -0,0 +1,3 @@
+import { EndpointHandler } from '@quatrain/api';
+import { BaseObject } from '@quatrain/core';
+export declare const ValuesEndpoint: (ModelClass: typeof BaseObject) => EndpointHandler;

package/dist/endpoints/ValuesEndpoint.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuesEndpoint = void 0;
+const backend_1 = require("@quatrain/backend");
+const ValuesEndpoint = (ModelClass) => {
+    return (router, path, options) => {
+        // Create the endpoint route, assuming 'path' is something like '/api/users'
+        // We'll map it to '/api/users/values' 
+        const valuesPath = path.endsWith('/') ? `${path}values` : `${path}/values`;
+        router.get(valuesPath, async (req, res) => {
+            try {
+                const results = await ModelClass.query()
+                    .where('status', 'deleted', 'notEquals')
+                    .execute('dataObjects');
+                // Identify exposed fields from PROPS_DEFINITION
+                const propsDef = ModelClass.PROPS_DEFINITION || [];
+                const exposedFields = propsDef
+                    .filter((p) => p.htmlType && p.htmlType !== 'off')
+                    .map((p) => p.name);
+                const searchFields = ['name', ...propsDef
+                        .filter((p) => p.type === 'StringProperty' && p.fullSearch === true)
+                        .map((p) => p.name)];
+                let values = results.items.map((dataObject) => {
+                    const payload = {
+                        value: dataObject.uid,
+                        name: dataObject.has('name') ? dataObject.get('name') : dataObject.uid
+                    };
+                    for (const field of exposedFields) {
+                        if (dataObject.has(field)) {
+                            payload[field] = dataObject.get(field);
+                        }
+                    }
+                    const searchVals = searchFields.map(f => {
+                        const val = dataObject.get(f);
+                        return typeof val === 'string' ? val : '';
+                    }).filter(Boolean);
+                    payload._search = searchVals.join(' ').toLowerCase();
+                    return payload;
+                });
+                const qParam = req.query.q;
+                if (qParam) {
+                    const searchStr = qParam.toLowerCase();
+                    values = values.filter((payload) => {
+                        return searchFields.some(field => {
+                            const val = payload[field];
+                            return typeof val === 'string' && val.toLowerCase().includes(searchStr);
+                        });
+                    });
+                }
+                res.json(values);
+            }
+            catch (e) {
+                backend_1.Backend.error(`[API Error] GET ${valuesPath}: ${e.message}`);
+                res.status(500).json({ error: e.message });
+            }
+        });
+    };
+};
+exports.ValuesEndpoint = ValuesEndpoint;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { ExpressAdapter } from './adapters/ExpressAdapter';
+export { CrudEndpoint } from './endpoints/CrudEndpoint';
+export { ListEndpoint } from './endpoints/ListEndpoint';
+export { ValuesEndpoint } from './endpoints/ValuesEndpoint';

package/dist/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuesEndpoint = exports.ListEndpoint = exports.CrudEndpoint = exports.ExpressAdapter = void 0;
+var ExpressAdapter_1 = require("./adapters/ExpressAdapter");
+Object.defineProperty(exports, "ExpressAdapter", { enumerable: true, get: function () { return ExpressAdapter_1.ExpressAdapter; } });
+var CrudEndpoint_1 = require("./endpoints/CrudEndpoint");
+Object.defineProperty(exports, "CrudEndpoint", { enumerable: true, get: function () { return CrudEndpoint_1.CrudEndpoint; } });
+var ListEndpoint_1 = require("./endpoints/ListEndpoint");
+Object.defineProperty(exports, "ListEndpoint", { enumerable: true, get: function () { return ListEndpoint_1.ListEndpoint; } });
+var ValuesEndpoint_1 = require("./endpoints/ValuesEndpoint");
+Object.defineProperty(exports, "ValuesEndpoint", { enumerable: true, get: function () { return ValuesEndpoint_1.ValuesEndpoint; } });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@quatrain/api-server-express",
+  "version": "1.1.6",
+  "description": "API Server Utilities for Quatrain",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
+  "files": [
+    "LICENSE.md",
+    "dist/",
+    "src/",
+    "README.md",
+    "NOTICE.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Quatrain/Core.git",
+    "directory": "packages/api-server"
+  },
+  "author": "Quatrain Développement SAS <developers@quatrain.com>",
+  "license": "AGPL-3.0-only",
+  "devDependencies": {
+    "@tsconfig/recommended": "^1.0.1",
+    "@types/express": "^4.17.21",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.10.1",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "@quatrain/api": "^1.1.3",
+    "@quatrain/backend": "^1.2.5",
+    "@quatrain/core": "^1.2.5",
+    "express": "^4.19.2"
+  },
+  "scripts": {
+    "test-ci": "jest --runInBand",
+    "build": "tsc",
+    "wbuild": "tsc --watch",
+    "bump-to": "yarn version"
+  }
+}

package/src/adapters/ExpressAdapter.ts

@@ -0,0 +1,129 @@
+import express from 'express'
+import { ServerAdapter, ApiHandler, ApiRequest, ApiResponse, EndpointHandler, EndpointOptions } from '@quatrain/api'
+
+export class ExpressAdapter implements ServerAdapter {
+   constructor(
+      private appOrRouter: express.Application | express.Router = express(),
+      private config: { apiPrefix?: string } = {}
+   ) {
+      if ('listen' in this.appOrRouter && typeof this.appOrRouter.listen === 'function') {
+         // Default global middlewares for top-level application
+         (this.appOrRouter as express.Application).disable('x-powered-by')
+         this.appOrRouter.use(express.json())
+         this.appOrRouter.use((req, res, next) => {
+            res.header('Access-Control-Allow-Origin', '*')
+            res.header('Access-Control-Allow-Methods', 'GET, PUT, POST, DELETE, OPTIONS')
+            res.header('Access-Control-Allow-Headers', '*')
+            if (req.method === 'OPTIONS') {
+               return res.sendStatus(200)
+            }
+            next()
+         })
+      }
+   }
+
+   private wrapHandler(handler: ApiHandler): express.RequestHandler {
+      return async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+         try {
+            const apiReq: ApiRequest = {
+               body: req.body,
+               params: req.params,
+               query: req.query
+            }
+
+            const apiRes: ApiResponse = {
+               status: (code: number) => {
+                  res.status(code)
+                  return apiRes
+               },
+               json: (data: any) => {
+                  res.json(data)
+               },
+               send: (data: string) => {
+                  res.send(data)
+               },
+               setHeader: (name: string, value: string) => {
+                  res.setHeader(name, value)
+               },
+               write: (data: string) => {
+                  res.write(data)
+               },
+               end: () => {
+                  res.end()
+               }
+            }
+
+            await handler(apiReq, apiRes)
+         } catch (err) {
+            next(err)
+         }
+      }
+   }
+
+   get(path: string, handler: ApiHandler): void {
+      (this.appOrRouter as express.Router).get(path, this.wrapHandler(handler))
+   }
+
+   post(path: string, handler: ApiHandler): void {
+      (this.appOrRouter as express.Router).post(path, this.wrapHandler(handler))
+   }
+
+   put(path: string, handler: ApiHandler): void {
+      (this.appOrRouter as express.Router).put(path, this.wrapHandler(handler))
+   }
+
+   delete(path: string, handler: ApiHandler): void {
+      (this.appOrRouter as express.Router).delete(path, this.wrapHandler(handler))
+   }
+
+   use(middleware: any): void {
+      (this.appOrRouter as express.Router).use(middleware)
+   }
+
+   createRouter(path: string): ServerAdapter {
+      const router = express.Router()
+      ;(this.appOrRouter as express.Router).use(path, router)
+      return new ExpressAdapter(router)
+   }
+
+   start(port: number, callback?: () => void): void {
+      if ('listen' in this.appOrRouter && typeof this.appOrRouter.listen === 'function') {
+         this.appOrRouter.listen(port, callback)
+      } else {
+         throw new Error("Cannot start a server on a Router instance.")
+      }
+   }
+
+   getNativeInstance(): any {
+      return this.appOrRouter
+   }
+
+   /**
+    * Configures the server to serve static files from a specified folder.
+    * It also sets up a fallback route for SPA (Single Page Application) navigation,
+    * ensuring that non-API routes return the main index.html file.
+    * 
+    * @param folderPath The absolute path to the directory containing static files (e.g. built frontend).
+    * @param apiPrefix The prefix used for API routes, which will be ignored by the SPA fallback. Defaults to '/api'.
+    */
+   serveStatic(folderPath: string, apiPrefix: string = '/api'): void {
+      const path = require('node:path')
+      this.use(express.static(folderPath))
+      
+      ;(this.appOrRouter as express.Router).get('*', (req: express.Request, res: express.Response, next: express.NextFunction) => {
+         if (req.path.startsWith(apiPrefix)) return next()
+         res.sendFile(path.join(folderPath, 'index.html'))
+      })
+   }
+
+   addEndpoint(handler: EndpointHandler, endpointRoot: string, options: EndpointOptions = {}): void {
+      const fullPath = this.config.apiPrefix ? `${this.config.apiPrefix}${endpointRoot}` : endpointRoot
+      const router = this.createRouter(fullPath)
+      
+      if (options.middlewares && options.middlewares.length > 0) {
+         options.middlewares.forEach((mw) => router.use(mw))
+      }
+      
+      handler(router, '/', options)
+   }
+}

package/src/endpoints/CrudEndpoint.ts

@@ -0,0 +1,106 @@
+import { EndpointHandler, ServerAdapter, EndpointOptions } from '@quatrain/api'
+import { BaseObject, DataObjectClass } from '@quatrain/core'
+import { Backend } from '@quatrain/backend'
+import { ValidationError } from '@quatrain/core'
+
+export const CrudEndpoint = (ModelClass: typeof BaseObject): EndpointHandler => {
+   return (router: ServerAdapter, path: string, options: EndpointOptions) => {
+      const methods = options.methods || ['CREATE', 'READ', 'UPDATE', 'DELETE']
+
+      // C: Create
+      if (methods.includes('CREATE')) {
+         router.post(path, async (req, res) => {
+            try {
+               const data = req.body
+               const newObj = await ModelClass.factory()
+               
+               Object.keys(data).forEach((key) => {
+                  if (newObj.has(key)) {
+                     newObj.set(key, data[key])
+                  }
+               });
+               
+               (newObj as any).validate()
+               await (newObj as any).save()
+               res.status(201).json(newObj.dataObject.toJSON())
+            } catch (e: any) {
+               if (e.name === 'ValidationError') {
+                  res.status(400).json({ error: e.message, validationErrors: e.errors })
+               } else {
+                  Backend.error(`[API Error] POST: ${e.message}`)
+                  res.status(400).json({ error: e.message })
+               }
+            }
+         })
+      }
+
+      // R: Read (Single by ID)
+      if (methods.includes('READ')) {
+         const getPath = path.endsWith('/') ? `${path}:id` : `${path}/:id`
+         router.get(getPath, async (req, res) => {
+            try {
+               const obj = await (ModelClass as any).fromBackend(req.params.id)
+               if (!obj) {
+                  return res.status(404).json({ error: 'Object not found' })
+               }
+               res.json(obj.dataObject.toJSON())
+            } catch (e) {
+               Backend.error(`[API Error] GET /${req.params.id}: ${(e as Error).message}`)
+               res.status(500).json({ error: (e as Error).message })
+            }
+         })
+      }
+
+      // U: Update
+      if (methods.includes('UPDATE')) {
+         const putPath = path.endsWith('/') ? `${path}:id` : `${path}/:id`
+         router.put(putPath, async (req, res) => {
+            try {
+               const data = req.body
+               const obj = await (ModelClass as any).fromBackend(req.params.id)
+                  
+               if (!obj) {
+                  return res.status(404).json({ error: 'Object not found' })
+               }
+               
+               Object.keys(data).forEach((key) => {
+                  if (obj.has(key)) {
+                     obj.set(key, data[key])
+                  }
+               });
+               
+               obj.validate()
+               await obj.save()
+               res.json(obj.dataObject.toJSON())
+            } catch (e: any) {
+               if (e.name === 'ValidationError') {
+                  res.status(400).json({ error: e.message, validationErrors: e.errors })
+               } else {
+                  Backend.error(`[API Error] PUT /${req.params.id}: ${e.message}`)
+                  res.status(400).json({ error: e.message })
+               }
+            }
+         })
+      }
+
+      // D: Delete
+      if (methods.includes('DELETE')) {
+         const deletePath = path.endsWith('/') ? `${path}:id` : `${path}/:id`
+         router.delete(deletePath, async (req, res) => {
+            try {
+               const obj = await (ModelClass as any).fromBackend(req.params.id)
+                  
+               if (!obj) {
+                  return res.status(404).json({ error: 'Object not found' })
+               }
+               
+               await obj.delete()
+               res.json({ success: true })
+            } catch (e) {
+               Backend.error(`[API Error] DELETE /${req.params.id}: ${(e as Error).message}`)
+               res.status(500).json({ error: (e as Error).message })
+            }
+         })
+      }
+   }
+}

package/src/endpoints/ListEndpoint.ts

@@ -0,0 +1,30 @@
+import { EndpointHandler, ServerAdapter, EndpointOptions } from '@quatrain/api'
+import { BaseObject, DataObjectClass } from '@quatrain/core'
+import { Backend } from '@quatrain/backend'
+
+export const ListEndpoint = (ModelClass: typeof BaseObject): EndpointHandler => {
+   return (router: ServerAdapter, path: string, options: EndpointOptions) => {
+      
+      router.get(path, async (req, res) => {
+         try {
+            let q = (ModelClass as any).query()
+            
+            // Apply all query parameters as exact match filters
+            for (const [key, value] of Object.entries(req.query)) {
+               q = q.where(key, value, 'equals')
+            }
+            
+            const results = await q.execute('dataObjects')
+            
+            res.json({
+               items: results.items.map((r: DataObjectClass<any>) => r.toJSON()),
+               meta: results.meta
+            })
+         } catch (e) {
+            Backend.error(`[API Error] GET (List): ${(e as Error).message}`)
+            res.status(500).json({ error: (e as Error).message })
+         }
+      })
+      
+   }
+}

package/src/endpoints/ValuesEndpoint.ts

@@ -0,0 +1,66 @@
+import { EndpointHandler, ServerAdapter, EndpointOptions } from '@quatrain/api'
+import { BaseObject, DataObjectClass } from '@quatrain/core'
+import { Backend } from '@quatrain/backend'
+
+export const ValuesEndpoint = (ModelClass: typeof BaseObject): EndpointHandler => {
+   return (router: ServerAdapter, path: string, options: EndpointOptions) => {
+      // Create the endpoint route, assuming 'path' is something like '/api/users'
+      // We'll map it to '/api/users/values' 
+      const valuesPath = path.endsWith('/') ? `${path}values` : `${path}/values`
+      
+      router.get(valuesPath, async (req, res) => {
+         try {
+            const results = await (ModelClass as any).query()
+               .where('status', 'deleted', 'notEquals')
+               .execute('dataObjects')
+            
+            // Identify exposed fields from PROPS_DEFINITION
+            const propsDef = (ModelClass as any).PROPS_DEFINITION || []
+            const exposedFields = propsDef
+               .filter((p: any) => p.htmlType && p.htmlType !== 'off')
+               .map((p: any) => p.name)
+            
+            const searchFields = ['name', ...propsDef
+               .filter((p: any) => p.type === 'StringProperty' && p.fullSearch === true)
+               .map((p: any) => p.name)]
+            
+            let values = results.items.map((dataObject: DataObjectClass<any>) => {
+               const payload: any = { 
+                  value: dataObject.uid,
+                  name: dataObject.has('name') ? dataObject.get('name') : dataObject.uid
+               }
+               
+               for (const field of exposedFields) {
+                  if (dataObject.has(field)) {
+                     payload[field] = dataObject.get(field)
+                  }
+               }
+               
+               const searchVals = searchFields.map(f => {
+                  const val = dataObject.get(f)
+                  return typeof val === 'string' ? val : ''
+               }).filter(Boolean)
+               payload._search = searchVals.join(' ').toLowerCase()
+               
+               return payload
+            })
+            
+            const qParam = req.query.q as string
+            if (qParam) {
+               const searchStr = qParam.toLowerCase()
+               values = values.filter((payload: any) => {
+                  return searchFields.some(field => {
+                     const val = payload[field]
+                     return typeof val === 'string' && val.toLowerCase().includes(searchStr)
+                  })
+               })
+            }
+            
+            res.json(values)
+         } catch (e) {
+            Backend.error(`[API Error] GET ${valuesPath}: ${(e as Error).message}`)
+            res.status(500).json({ error: (e as Error).message })
+         }
+      })
+   }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { ExpressAdapter } from './adapters/ExpressAdapter'
+
+export { CrudEndpoint } from './endpoints/CrudEndpoint'
+export { ListEndpoint } from './endpoints/ListEndpoint'
+export { ValuesEndpoint } from './endpoints/ValuesEndpoint'