Templates and agreement partial fetch and pagination #15

server/index.ts

@@ -1,48 +1,29 @@
-import 'source-map-support/register';
-import OpenAPIBackend, { Request } from 'openapi-backend';
-import Express from 'express';
-import morgan from 'morgan'
-import path from 'path';
+import "source-map-support/register";
+import OpenAPIBackend, { Request as OpenAPIRequest } from "openapi-backend";
+import express from "express";
+import morgan from "morgan";
+import path from "path";
+import * as templateHandlers from "./src/handlers/templates";
+import * as agreementHandlers from "./src/handlers/agreements";
+import * as defaultHandlers from "./src/handlers/defaults";
 
-import { Request as ExpressReq, Response as ExpressRes } from 'express';
+const app = express();
+app.use(express.json());
 
-const app = Express();
-app.use(Express.json());
+const openApiPath = path.join(__dirname, "..", "..", "openapi.json");
+console.log(`Loading OpenAPI definition from: ${openApiPath}`);
 
-const openApiPath = path.join(__dirname, '..', '..', 'openapi.json');
-console.log(openApiPath);
-
-// define api
 const api = new OpenAPIBackend({
-    quick: true, // disabled validation of OpenAPI on load
-    definition: openApiPath,
-    handlers: {
-        listTemplates: async (c, req: Express.Request, res: Express.Response) =>
-            res.status(200).json([]),
-        createTemplate: async (c, req: Express.Request, res: Express.Response) =>
-            res.status(200).json({}),
-        getTemplate: async (c, req: Express.Request, res: Express.Response) =>
-            res.status(200).json({}),
-        replaceTemplate: async (c, req: Express.Request, res: Express.Response) =>
-            res.status(200).json({}),
-        deleteTemplate: async (c, req: Express.Request, res: Express.Response) =>
-            res.status(200).json({}),
-        validationFail: async (c, req: ExpressReq, res: ExpressRes) => res.status(400).json({ err: c.validation.errors }),
-        notFound: async (c, req: ExpressReq, res: ExpressRes) => res.status(404).json({ err: 'not found' }),
-        notImplemented: async (c, req: ExpressReq, res: ExpressRes) => {
-            const { status, mock } = c.api.mockResponseForOperation(c.operation.operationId);
-            return res.status(status).json(mock);
-        },
-    },
+  quick: true,
+  definition: openApiPath,
+  handlers: {
+    ...templateHandlers,
+    ...agreementHandlers,
+    ...defaultHandlers,
+  },
 });
 
 api.init();
-
-// logging
-app.use(morgan('combined'));
-
-// use as express middleware
-app.use((req, res) => api.handleRequest(req as Request, req, res));
-
-// start server
-app.listen(9000, () => console.info('api listening at http://localhost:9000'));
+app.use(morgan("combined"));
+app.use((req, res) => api.handleRequest(req as OpenAPIRequest, req, res));
+app.listen(9000, () => console.info("API listening at http://localhost:9000"));

server/src/handlers/agreements.ts

@@ -0,0 +1,140 @@
+import {
+  Request as ExpressRequest,
+  Response as ExpressResponse,
+} from "express";
+
+import agreements from "../models/agreement";
+import {
+  Agreement,
+  TriggerRequest,
+  TriggerResponse,
+} from "../models/agreement";
+import { paginate } from "../utils/pagination";
+import { filterFields } from "../utils/filters";
+
+export const listAgreements = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => {
+  const offset = parseInt(req.query.offset as string) || 0;
+  const limit = Math.min(parseInt(req.query.limit as string) || 10, 100);
+  const fields =
+    typeof req.query.fields === "string"
+      ? req.query.fields.split(",")
+      : ["id", "name", "createdAt"];
+  const full = req.query.full === "true";
+  const baseUrl = `${req.protocol}://${req.get("host")}${req.path}`;
+
+  const allAgreements = Object.values(agreements);
+  const responseData = full
+    ? allAgreements
+    : allAgreements.map((agreement) => filterFields(agreement, fields));
+
+  const paginatedResult = paginate(responseData, offset, limit, baseUrl);
+  return res.status(200).json(paginatedResult);
+};
+
+// Create Agreement
+export const createAgreement = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => {
+  const { name, details } = req.body as Partial<Agreement>;
+  if (!name || !details) {
+    return res.status(400).json({ error: "Name and details are required" });
+  }
+  const id = (Object.keys(agreements).length + 101).toString();
+  const newAgreement: Agreement = {
+    id,
+    name,
+    createdAt: new Date().toISOString(),
+    details,
+  };
+  agreements[id] = newAgreement;
+  return res.status(201).json(newAgreement);
+};
+
+// Get Agreement
+export const getAgreement = async (
+  c: any,
+  req: ExpressRequest<{ agreementId: string }>,
+  res: ExpressResponse
+) => {
+  const { agreementId } = req.params;
+  if (!agreements[agreementId]) {
+    return res.status(404).json({ error: "Agreement not found" });
+  }
+  return res.status(200).json(agreements[agreementId]);
+};
+
+// Replace Agreement
+export const replaceAgreement = async (
+  c: any,
+  req: ExpressRequest<{ agreementId: string }>,
+  res: ExpressResponse
+) => {
+  const { agreementId } = req.params;
+  if (!agreements[agreementId]) {
+    return res.status(404).json({ error: "Agreement not found" });
+  }
+  const { name, details } = req.body as Partial<Agreement>;
+  const updatedAgreement: Agreement = {
+    id: agreementId,
+    name: name || agreements[agreementId].name,
+    createdAt: agreements[agreementId].createdAt,
+    details: details || agreements[agreementId].details,
+  };
+  agreements[agreementId] = updatedAgreement;
+  return res.status(202).json(updatedAgreement);
+};
+
+// Delete Agreement
+export const deleteAgreement = async (
+  c: any,
+  req: ExpressRequest<{ agreementId: string }>,
+  res: ExpressResponse
+) => {
+  const { agreementId } = req.params;
+  if (!agreements[agreementId]) {
+    return res.status(404).json({ error: "Agreement not found" });
+  }
+  delete agreements[agreementId];
+  return res.status(204).send();
+};
+
+// Convert Agreement to PDF (Removed unused 'options')
+export const convertAgreementPdf = async (
+  c: any,
+  req: ExpressRequest<{ agreementId: string }>,
+  res: ExpressResponse
+) => {
+  const { agreementId } = req.params;
+  if (!agreements[agreementId]) {
+    return res.status(404).json({ error: "Agreement not found" });
+  }
+  // Mock PDF response (replace with actual PDF generation logic)
+  const pdfMock = Buffer.from(`Mock PDF for ${agreementId}`);
+  res.setHeader("Content-Type", "application/pdf");
+  return res.status(202).send(pdfMock);
+};
+
+// Trigger Agreement
+export const triggerAgreement = async (
+  c: any,
+  req: ExpressRequest<{ agreementId: string }>,
+  res: ExpressResponse
+) => {
+  const { agreementId } = req.params;
+  if (!agreements[agreementId]) {
+    return res.status(404).json({ error: "Agreement not found" });
+  }
+  const triggerData = req.body as TriggerRequest;
+  const response: TriggerResponse = {
+    result: `Triggered ${agreementId} with data: ${JSON.stringify(
+      triggerData.data
+    )}`,
+  };
+  return res.status(200).json(response);
+};

server/src/handlers/defaults.ts

@@ -0,0 +1,25 @@
+import {
+  Request as ExpressRequest,
+  Response as ExpressResponse,
+} from "express";
+
+export const validationFail = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => res.status(400).json({ error: c.validation.errors });
+export const notFound = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => res.status(404).json({ error: "Not found" });
+export const notImplemented = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => {
+  const { status, mock } = c.api.mockResponseForOperation(
+    c.operation.operationId
+  );
+  return res.status(status).json(mock);
+};

server/src/handlers/templates.ts

@@ -0,0 +1,103 @@
+import {
+  Request as ExpressRequest,
+  Response as ExpressResponse,
+} from "express";
+import { templates } from "../models/template";
+import { paginate } from "../utils/pagination";
+import { filterFields } from "../utils/filters";
+import { Template } from "../models/template";
+
+export const listTemplates = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => {
+  const offset = parseInt(req.query.offset as string) || 0;
+  const limit = Math.min(parseInt(req.query.limit as string) || 10, 100);
+  const fields =
+    typeof req.query.fields === "string"
+      ? req.query.fields.split(",")
+      : ["id", "name", "createdAt"];
+  const full = req.query.full === "true";
+  const baseUrl = `${req.protocol}://${req.get("host")}${req.path}`;
+
+  const allTemplates = Object.values(templates);
+  const responseData = full
+    ? allTemplates
+    : allTemplates.map((template) => filterFields(template, fields));
+
+  const paginatedResult = paginate(responseData, offset, limit, baseUrl);
+  return res.status(200).json(paginatedResult);
+};
+
+// Add createTemplate, getTemplate, replaceTemplate, deleteTemplate similarly...
+
+// Create Template
+
+export const createTemplate = async (
+  c: any,
+  req: ExpressRequest,
+  res: ExpressResponse
+) => {
+  const { name, content } = req.body as Partial<Template>;
+  if (!name || !content) {
+    return res.status(400).json({ error: "Name and content are required" });
+  }
+  const id = (Object.keys(templates).length + 1).toString();
+  const newTemplate: Template = {
+    id,
+    name,
+    createdAt: new Date().toISOString(),
+    content,
+  };
+  templates[id] = newTemplate;
+  return res.status(201).json(newTemplate);
+};
+
+// Get Template
+export const getTemplate = async (
+  c: any,
+  req: ExpressRequest<{ name: string }>,
+  res: ExpressResponse
+) => {
+  const { name } = req.params;
+  if (!templates[name]) {
+    return res.status(404).json({ error: "Template not found" });
+  }
+  return res.status(200).json(templates[name]);
+};
+
+// Replace Template
+export const replaceTemplate = async (
+  c: any,
+  req: ExpressRequest<{ name: string }>,
+  res: ExpressResponse
+) => {
+  const { name: templateId } = req.params;
+  if (!templates[templateId]) {
+    return res.status(404).json({ error: "Template not found" });
+  }
+  const { name, content } = req.body as Partial<Template>;
+  const updatedTemplate: Template = {
+    id: templateId,
+    name: name || templates[templateId].name,
+    createdAt: templates[templateId].createdAt,
+    content: content || templates[templateId].content,
+  };
+  templates[templateId] = updatedTemplate;
+  return res.status(202).json(updatedTemplate);
+};
+
+// Delete Template
+export const deleteTemplate = async (
+  c: any,
+  req: ExpressRequest<{ name: string }>,
+  res: ExpressResponse
+) => {
+  const { name: templateId } = req.params;
+  if (!templates[templateId]) {
+    return res.status(404).json({ error: "Template not found" });
+  }
+  delete templates[templateId];
+  return res.status(204).send();
+};

server/src/models/agreement.ts

@@ -0,0 +1,37 @@
+export interface Agreement {
+  id: string;
+  name: string;
+  createdAt: string;
+  details: string;
+}
+
+export interface TriggerRequest {
+  data: any; // JSON-serialized Concerto type, adjust as needed
+}
+
+export interface TriggerResponse {
+  result: any; // Adjust based on actual response structure
+}
+
+const agreements: Record<string, Agreement> = {
+  "101": {
+    id: "101",
+    name: "Agreement A",
+    createdAt: "2024-02-01",
+    details: "Agreement details A",
+  },
+  "102": {
+    id: "102",
+    name: "Agreement B",
+    createdAt: "2024-02-02",
+    details: "Agreement details B",
+  },
+  "103": {
+    id: "103",
+    name: "Agreement C",
+    createdAt: "2024-02-03",
+    details: "Agreement details C",
+  },
+};
+
+export default agreements;