@quatrain/api-server-express 1.1.6 → 1.1.8

package/dist/adapters/ExpressAdapter.d.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { ServerAdapter, ApiHandler, EndpointHandler, EndpointOptions } from '@quatrain/api';
+import { ServerAdapter, ApiHandler, EndpointHandler, EndpointOptions, ApiMiddleware } from '@quatrain/api';
 export declare class ExpressAdapter implements ServerAdapter {
     private appOrRouter;
     private config;
@@ -12,6 +12,7 @@ export declare class ExpressAdapter implements ServerAdapter {
     put(path: string, handler: ApiHandler): void;
     delete(path: string, handler: ApiHandler): void;
     use(middleware: any): void;
+    addMiddleware(middleware: ApiMiddleware): void;
     createRouter(path: string): ServerAdapter;
     start(port: number, callback?: () => void): void;
     getNativeInstance(): any;

package/dist/adapters/ExpressAdapter.js

@@ -32,7 +32,8 @@ class ExpressAdapter {
                 const apiReq = {
                     body: req.body,
                     params: req.params,
-                    query: req.query
+                    query: req.query,
+                    headers: req.headers
                 };
                 const apiRes = {
                     status: (code) => {
@@ -77,6 +78,47 @@ class ExpressAdapter {
     use(middleware) {
         this.appOrRouter.use(middleware);
     }
+    addMiddleware(middleware) {
+        const expressMiddleware = async (req, res, next) => {
+            const apiReq = {
+                body: req.body,
+                params: req.params,
+                query: req.query,
+                headers: req.headers
+            };
+            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();
+                }
+            };
+            try {
+                const shouldContinue = await middleware(apiReq, apiRes);
+                if (shouldContinue) {
+                    next();
+                }
+            }
+            catch (err) {
+                next(err);
+            }
+        };
+        this.appOrRouter.use(expressMiddleware);
+    }
     createRouter(path) {
         const router = express_1.default.Router();
         this.appOrRouter.use(path, router);

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,11 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValuesEndpoint = exports.ListEndpoint = exports.CrudEndpoint = exports.ExpressAdapter = void 0;
+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

@@ -1,7 +1,7 @@
 {
   "name": "@quatrain/api-server-express",
-  "version": "1.1.6",
-  "description": "API Server Utilities for Quatrain",
+  "version": "1.1.8",
+  "description": "Express Adapter for Quatrain API Server",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bun": "src/index.ts",
@@ -15,7 +15,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Quatrain/Core.git",
-    "directory": "packages/api-server"
+    "directory": "packages/api-server-express"
   },
   "author": "Quatrain Développement SAS <developers@quatrain.com>",
   "license": "AGPL-3.0-only",
@@ -29,9 +29,8 @@
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@quatrain/api": "^1.1.3",
-    "@quatrain/backend": "^1.2.5",
-    "@quatrain/core": "^1.2.5",
+    "@quatrain/api": "^1.1.4",
+    "@quatrain/api-server": "^1.1.8",
     "express": "^4.19.2"
   },
   "scripts": {

package/src/adapters/ExpressAdapter.ts

@@ -1,5 +1,5 @@
 import express from 'express'
-import { ServerAdapter, ApiHandler, ApiRequest, ApiResponse, EndpointHandler, EndpointOptions } from '@quatrain/api'
+import { ServerAdapter, ApiHandler, ApiRequest, ApiResponse, EndpointHandler, EndpointOptions, ApiMiddleware } from '@quatrain/api'
 
 export class ExpressAdapter implements ServerAdapter {
    constructor(
@@ -28,7 +28,8 @@ export class ExpressAdapter implements ServerAdapter {
             const apiReq: ApiRequest = {
                body: req.body,
                params: req.params,
-               query: req.query
+               query: req.query,
+               headers: req.headers as Record<string, string | string[] | undefined>
             }
 
             const apiRes: ApiResponse = {
@@ -80,6 +81,49 @@ export class ExpressAdapter implements ServerAdapter {
       (this.appOrRouter as express.Router).use(middleware)
    }
 
+   addMiddleware(middleware: ApiMiddleware): void {
+      const expressMiddleware = async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+         const apiReq: ApiRequest = {
+            body: req.body,
+            params: req.params,
+            query: req.query,
+            headers: req.headers as Record<string, string | string[] | undefined>
+         }
+
+         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()
+            }
+         }
+
+         try {
+            const shouldContinue = await middleware(apiReq, apiRes)
+            if (shouldContinue) {
+               next()
+            }
+         } catch (err) {
+            next(err)
+         }
+      }
+      (this.appOrRouter as express.Router).use(expressMiddleware)
+   }
+
    createRouter(path: string): ServerAdapter {
       const router = express.Router()
       ;(this.appOrRouter as express.Router).use(path, router)

package/src/index.ts

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

package/README.md

@@ -1,13 +0,0 @@
-# @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/endpoints/CrudEndpoint.d.ts

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

package/dist/endpoints/CrudEndpoint.js

@@ -1,101 +0,0 @@
-"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

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

package/dist/endpoints/ListEndpoint.js

@@ -1,27 +0,0 @@
-"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

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

package/dist/endpoints/ValuesEndpoint.js

@@ -1,59 +0,0 @@
-"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/src/endpoints/CrudEndpoint.ts

@@ -1,106 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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 })
-         }
-      })
-   }
-}