@budibase/server 1.0.78 → 1.0.79-alpha.10

package/dist/api/controllers/webhook.js

@@ -11,6 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 const { generateWebhookID, getWebhookParams } = require("../../db/utils");
 const toJsonSchema = require("to-json-schema");
 const validate = require("jsonschema").validate;
+const { WebhookType } = require("../../constants");
 const triggers = require("../../automations/triggers");
 const { getProdAppID } = require("@budibase/backend-core/db");
 const { getAppDB, updateAppId } = require("@budibase/backend-core/context");
@@ -24,9 +25,6 @@ function Webhook(name, type, target) {
     };
 }
 exports.Webhook = Webhook;
-exports.WebhookType = {
-    AUTOMATION: "automation",
-};
 exports.fetch = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const db = getAppDB();
     const response = yield db.allDocs(getWebhookParams(null, {
@@ -62,7 +60,7 @@ exports.buildSchema = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
     const webhook = yield db.get(ctx.params.id);
     webhook.bodySchema = toJsonSchema(ctx.request.body);
     // update the automation outputs
-    if (webhook.action.type === exports.WebhookType.AUTOMATION) {
+    if (webhook.action.type === WebhookType.AUTOMATION) {
         let automation = yield db.get(webhook.action.target);
         const autoOutputs = automation.definition.trigger.schema.outputs;
         let properties = webhook.bodySchema.properties;
@@ -91,7 +89,7 @@ exports.trigger = (ctx) => __awaiter(void 0, void 0, void 0, function* () {
             validate(ctx.request.body, webhook.bodySchema);
         }
         const target = yield db.get(webhook.action.target);
-        if (webhook.action.type === exports.WebhookType.AUTOMATION) {
+        if (webhook.action.type === WebhookType.AUTOMATION) {
             // trigger with both the pure request and then expand it
             // incase the user has produced a schema to bind to
             yield triggers.externalTrigger(target, Object.assign(Object.assign({ body: ctx.request.body }, ctx.request.body), { appId: prodAppId }));

package/dist/api/index.js

@@ -13,7 +13,7 @@ const { buildAuthMiddleware, auditLog, buildTenancyMiddleware, buildAppTenancyMi
 const currentApp = require("../middleware/currentapp");
 const compress = require("koa-compress");
 const zlib = require("zlib");
-const { mainRoutes, staticRoutes } = require("./routes");
+const { mainRoutes, staticRoutes, publicRoutes } = require("./routes");
 const pkg = require("../../package.json");
 const env = require("../environment");
 const router = new Router();
@@ -76,6 +76,8 @@ for (let route of mainRoutes) {
     router.use(route.routes());
     router.use(route.allowedMethods());
 }
+router.use(publicRoutes.routes());
+router.use(publicRoutes.allowedMethods());
 // WARNING - static routes will catch everything else after them this must be last
 router.use(staticRoutes.routes());
 router.use(staticRoutes.allowedMethods());

package/dist/api/routes/automation.js

@@ -2,47 +2,19 @@
 const Router = require("@koa/router");
 const controller = require("../controllers/automation");
 const authorized = require("../../middleware/authorized");
-const joiValidator = require("../../middleware/joi-validator");
 const { BUILDER, PermissionLevels, PermissionTypes, } = require("@budibase/backend-core/permissions");
-const Joi = require("joi");
 const { bodyResource, paramResource } = require("../../middleware/resourceId");
 const { middleware: appInfoMiddleware, AppType, } = require("../../middleware/appInfo");
+const { automationValidator } = require("./utils/validators");
 const router = Router();
-// prettier-ignore
-function generateStepSchema(allowStepTypes) {
-    return Joi.object({
-        stepId: Joi.string().required(),
-        id: Joi.string().required(),
-        description: Joi.string().required(),
-        name: Joi.string().required(),
-        tagline: Joi.string().required(),
-        icon: Joi.string().required(),
-        params: Joi.object(),
-        args: Joi.object(),
-        type: Joi.string().required().valid(...allowStepTypes),
-    }).unknown(true);
-}
-function generateValidator(existing = false) {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        _id: existing ? Joi.string().required() : Joi.string(),
-        _rev: existing ? Joi.string().required() : Joi.string(),
-        name: Joi.string().required(),
-        type: Joi.string().valid("automation").required(),
-        definition: Joi.object({
-            steps: Joi.array().required().items(generateStepSchema(["ACTION", "LOGIC"])),
-            trigger: generateStepSchema(["TRIGGER"]).allow(null),
-        }).required().unknown(true),
-    }).unknown(true));
-}
 router
     .get("/api/automations/trigger/list", authorized(BUILDER), controller.getTriggerList)
     .get("/api/automations/action/list", authorized(BUILDER), controller.getActionList)
     .get("/api/automations/definitions/list", authorized(BUILDER), controller.getDefinitionList)
     .get("/api/automations", authorized(BUILDER), controller.fetch)
     .get("/api/automations/:id", paramResource("id"), authorized(BUILDER), controller.find)
-    .put("/api/automations", bodyResource("_id"), authorized(BUILDER), generateValidator(true), controller.update)
-    .post("/api/automations", authorized(BUILDER), generateValidator(false), controller.create)
+    .put("/api/automations", bodyResource("_id"), authorized(BUILDER), automationValidator(true), controller.update)
+    .post("/api/automations", authorized(BUILDER), automationValidator(false), controller.create)
     .delete("/api/automations/:id/:rev", paramResource("id"), authorized(BUILDER), controller.destroy)
     .post("/api/automations/:id/trigger", appInfoMiddleware({ appType: AppType.PROD }), paramResource("id"), authorized(PermissionTypes.AUTOMATION, PermissionLevels.EXECUTE), controller.trigger)
     .post("/api/automations/:id/test", appInfoMiddleware({ appType: AppType.DEV }), paramResource("id"), authorized(PermissionTypes.AUTOMATION, PermissionLevels.EXECUTE), controller.test);

package/dist/api/routes/datasource.js

@@ -2,62 +2,15 @@
 const Router = require("@koa/router");
 const datasourceController = require("../controllers/datasource");
 const authorized = require("../../middleware/authorized");
-const joiValidator = require("../../middleware/joi-validator");
 const { BUILDER, PermissionLevels, PermissionTypes, } = require("@budibase/backend-core/permissions");
-const Joi = require("joi");
-const { DataSourceOperation } = require("../../constants");
+const { datasourceValidator, datasourceQueryValidator, } = require("./utils/validators");
 const router = Router();
-function generateDatasourceSchema() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        _id: Joi.string(),
-        _rev: Joi.string(),
-        // source: Joi.string().valid("POSTGRES_PLUS"),
-        type: Joi.string().allow("datasource_plus"),
-        relationships: Joi.array().items(Joi.object({
-            from: Joi.string().required(),
-            to: Joi.string().required(),
-            cardinality: Joi.valid("1:N", "1:1", "N:N").required()
-        })),
-        // entities: Joi.array().items(Joi.object({
-        //   type: Joi.string().valid(...Object.values(FieldTypes)).required(),
-        //   name: Joi.string().required(),
-        // })),
-    }).unknown(true));
-}
-function generateQueryDatasourceSchema() {
-    // prettier-ignore
-    return joiValidator.body(Joi.object({
-        endpoint: Joi.object({
-            datasourceId: Joi.string().required(),
-            operation: Joi.string().required().valid(...Object.values(DataSourceOperation)),
-            entityId: Joi.string().required(),
-        }).required(),
-        resource: Joi.object({
-            fields: Joi.array().items(Joi.string()).optional(),
-        }).optional(),
-        body: Joi.object().optional(),
-        sort: Joi.object().optional(),
-        filters: Joi.object({
-            string: Joi.object().optional(),
-            range: Joi.object().optional(),
-            equal: Joi.object().optional(),
-            notEqual: Joi.object().optional(),
-            empty: Joi.object().optional(),
-            notEmpty: Joi.object().optional(),
-        }).optional(),
-        paginate: Joi.object({
-            page: Joi.string().alphanum().optional(),
-            limit: Joi.number().optional(),
-        }).optional(),
-    }));
-}
 router
     .get("/api/datasources", authorized(BUILDER), datasourceController.fetch)
     .get("/api/datasources/:datasourceId", authorized(PermissionTypes.TABLE, PermissionLevels.READ), datasourceController.find)
     .put("/api/datasources/:datasourceId", authorized(PermissionTypes.TABLE, PermissionLevels.READ), datasourceController.update)
-    .post("/api/datasources/query", authorized(PermissionTypes.TABLE, PermissionLevels.READ), generateQueryDatasourceSchema(), datasourceController.query)
+    .post("/api/datasources/query", authorized(PermissionTypes.TABLE, PermissionLevels.READ), datasourceQueryValidator(), datasourceController.query)
     .post("/api/datasources/:datasourceId/schema", authorized(BUILDER), datasourceController.buildSchemaFromDb)
-    .post("/api/datasources", authorized(BUILDER), generateDatasourceSchema(), datasourceController.save)
+    .post("/api/datasources", authorized(BUILDER), datasourceValidator(), datasourceController.save)
     .delete("/api/datasources/:datasourceId/:revId", authorized(BUILDER), datasourceController.destroy);
 module.exports = router;

package/dist/api/routes/index.js

@@ -26,6 +26,7 @@ const metadataRoutes = require("./metadata");
 const devRoutes = require("./dev");
 const cloudRoutes = require("./cloud");
 const migrationRoutes = require("./migrations");
+const publicRoutes = require("./public");
 exports.mainRoutes = [
     authRoutes,
     deployRoutes,
@@ -56,4 +57,5 @@ exports.mainRoutes = [
     rowRoutes,
     migrationRoutes,
 ];
+exports.publicRoutes = publicRoutes;
 exports.staticRoutes = staticRoutes;

package/dist/api/routes/permission.js

@@ -2,26 +2,16 @@
 const Router = require("@koa/router");
 const controller = require("../controllers/permission");
 const authorized = require("../../middleware/authorized");
-const { BUILDER, PermissionLevels, } = require("@budibase/backend-core/permissions");
-const Joi = require("joi");
-const joiValidator = require("../../middleware/joi-validator");
+const { BUILDER } = require("@budibase/backend-core/permissions");
+const { permissionValidator } = require("./utils/validators");
 const router = Router();
-function generateValidator() {
-    const permLevelArray = Object.values(PermissionLevels);
-    // prettier-ignore
-    return joiValidator.params(Joi.object({
-        level: Joi.string().valid(...permLevelArray).required(),
-        resourceId: Joi.string(),
-        roleId: Joi.string(),
-    }).unknown(true));
-}
 router
     .get("/api/permission/builtin", authorized(BUILDER), controller.fetchBuiltin)
     .get("/api/permission/levels", authorized(BUILDER), controller.fetchLevels)
     .get("/api/permission", authorized(BUILDER), controller.fetch)
     .get("/api/permission/:resourceId", authorized(BUILDER), controller.getResourcePerms)
     // adding a specific role/level for the resource overrides the underlying access control
-    .post("/api/permission/:roleId/:resourceId/:level", authorized(BUILDER), generateValidator(), controller.addPermission)
+    .post("/api/permission/:roleId/:resourceId/:level", authorized(BUILDER), permissionValidator(), controller.addPermission)
     // deleting the level defaults it back the underlying access control for the resource
-    .delete("/api/permission/:roleId/:resourceId/:level", authorized(BUILDER), generateValidator(), controller.removePermission);
+    .delete("/api/permission/:roleId/:resourceId/:level", authorized(BUILDER), permissionValidator(), controller.removePermission);
 module.exports = router;

package/dist/api/routes/public/applications.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const applications_1 = __importDefault(require("../../controllers/public/applications"));
+const Endpoint_1 = __importDefault(require("./utils/Endpoint"));
+const { nameValidator, applicationValidator } = require("../utils/validators");
+const read = [], write = [];
+/**
+ * @openapi
+ * /applications:
+ *   post:
+ *     summary: Create an application
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/application'
+ *     responses:
+ *       200:
+ *         description: Returns the created application.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/applicationOutput'
+ *             examples:
+ *               application:
+ *                 $ref: '#/components/examples/application'
+ */
+write.push(new Endpoint_1.default("post", "/applications", applications_1.default.create).addMiddleware(applicationValidator()));
+/**
+ * @openapi
+ * /applications/{appId}:
+ *   put:
+ *     summary: Update an application
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appIdUrl'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/application'
+ *     responses:
+ *       200:
+ *         description: Returns the updated application.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/applicationOutput'
+ *             examples:
+ *               application:
+ *                 $ref: '#/components/examples/application'
+ */
+write.push(new Endpoint_1.default("put", "/applications/:appId", applications_1.default.update).addMiddleware(applicationValidator()));
+/**
+ * @openapi
+ * /applications/{appId}:
+ *   delete:
+ *     summary: Delete an application
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appIdUrl'
+ *     responses:
+ *       200:
+ *         description: Returns the deleted application.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/applicationOutput'
+ *             examples:
+ *               application:
+ *                 $ref: '#/components/examples/application'
+ */
+write.push(new Endpoint_1.default("delete", "/applications/:appId", applications_1.default.destroy));
+/**
+ * @openapi
+ * /applications/{appId}:
+ *   get:
+ *     summary: Retrieve an application
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appIdUrl'
+ *     responses:
+ *       200:
+ *         description: Returns the retrieved application.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/applicationOutput'
+ *             examples:
+ *               application:
+ *                 $ref: '#/components/examples/application'
+ */
+read.push(new Endpoint_1.default("get", "/applications/:appId", applications_1.default.read));
+/**
+ * @openapi
+ * /applications/search:
+ *   post:
+ *     summary: Search for applications
+ *     description: Based on application properties (currently only name) search for applications.
+ *     tags:
+ *       - applications
+ *     parameters:
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/nameSearch'
+ *     responses:
+ *       200:
+ *         description: Returns the applications that were found based on the search parameters.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               required:
+ *                 - data
+ *               properties:
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/application'
+ *             examples:
+ *               applications:
+ *                 $ref: '#/components/examples/applications'
+ */
+read.push(new Endpoint_1.default("post", "/applications/search", applications_1.default.search).addMiddleware(nameValidator()));
+exports.default = { read, write };

package/dist/api/routes/public/index.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const applications_1 = __importDefault(require("./applications"));
+const queries_1 = __importDefault(require("./queries"));
+const tables_1 = __importDefault(require("./tables"));
+const rows_1 = __importDefault(require("./rows"));
+const users_1 = __importDefault(require("./users"));
+const usageQuota_1 = __importDefault(require("../../../middleware/usageQuota"));
+const authorized_1 = __importDefault(require("../../../middleware/authorized"));
+const resourceId_1 = require("../../../middleware/resourceId");
+const mapper_1 = __importDefault(require("./middleware/mapper"));
+const Router = require("@koa/router");
+const { PermissionLevels, PermissionTypes, } = require("@budibase/backend-core/permissions");
+const PREFIX = "/api/public/v1";
+const publicRouter = new Router({
+    prefix: PREFIX,
+});
+function addMiddleware(endpoints, middleware, opts = { output: false }) {
+    if (!endpoints) {
+        return;
+    }
+    if (!Array.isArray(endpoints)) {
+        endpoints = [endpoints];
+    }
+    for (let endpoint of endpoints) {
+        if (opts === null || opts === void 0 ? void 0 : opts.output) {
+            endpoint.addOutputMiddleware(middleware);
+        }
+        else {
+            endpoint.addMiddleware(middleware);
+        }
+    }
+}
+function addToRouter(endpoints) {
+    if (endpoints) {
+        for (let endpoint of endpoints) {
+            endpoint.apply(publicRouter);
+        }
+    }
+}
+function applyRoutes(endpoints, permType, resource, subResource) {
+    const paramMiddleware = subResource
+        ? resourceId_1.paramSubResource(resource, subResource)
+        : resourceId_1.paramResource(resource);
+    // add the parameter capture middleware
+    addMiddleware(endpoints.read, paramMiddleware);
+    addMiddleware(endpoints.write, paramMiddleware);
+    // add the authorization middleware, using the correct perm type
+    addMiddleware(endpoints.read, authorized_1.default(permType, PermissionLevels.READ));
+    addMiddleware(endpoints.write, authorized_1.default(permType, PermissionLevels.WRITE));
+    // add the usage quota middleware
+    addMiddleware(endpoints.write, usageQuota_1.default);
+    // add the output mapper middleware
+    addMiddleware(endpoints.read, mapper_1.default, { output: true });
+    addMiddleware(endpoints.write, mapper_1.default, { output: true });
+    addToRouter(endpoints.read);
+    addToRouter(endpoints.write);
+}
+applyRoutes(applications_1.default, PermissionTypes.APP, "appId");
+applyRoutes(tables_1.default, PermissionTypes.TABLE, "tableId");
+applyRoutes(users_1.default, PermissionTypes.USER, "userId");
+applyRoutes(queries_1.default, PermissionTypes.QUERY, "queryId");
+// needs to be applied last for routing purposes, don't override other endpoints
+applyRoutes(rows_1.default, PermissionTypes.TABLE, "tableId", "rowId");
+module.exports = publicRouter;

package/dist/api/routes/public/middleware/mapper.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapping_1 = __importDefault(require("../../../controllers/public/mapping"));
+var Resources;
+(function (Resources) {
+    Resources["APPLICATION"] = "applications";
+    Resources["TABLES"] = "tables";
+    Resources["ROWS"] = "rows";
+    Resources["USERS"] = "users";
+    Resources["QUERIES"] = "queries";
+    Resources["SEARCH"] = "search";
+})(Resources || (Resources = {}));
+function isArrayResponse(ctx) {
+    return ctx.url.endsWith(Resources.SEARCH) || Array.isArray(ctx.body);
+}
+function processApplications(ctx) {
+    if (isArrayResponse(ctx)) {
+        return mapping_1.default.mapApplications(ctx);
+    }
+    else {
+        return mapping_1.default.mapApplication(ctx);
+    }
+}
+function processTables(ctx) {
+    if (isArrayResponse(ctx)) {
+        return mapping_1.default.mapTables(ctx);
+    }
+    else {
+        return mapping_1.default.mapTable(ctx);
+    }
+}
+function processRows(ctx) {
+    if (isArrayResponse(ctx)) {
+        return mapping_1.default.mapRowSearch(ctx);
+    }
+    else {
+        return mapping_1.default.mapRow(ctx);
+    }
+}
+function processUsers(ctx) {
+    if (isArrayResponse(ctx)) {
+        return mapping_1.default.mapUsers(ctx);
+    }
+    else {
+        return mapping_1.default.mapUser(ctx);
+    }
+}
+function processQueries(ctx) {
+    if (isArrayResponse(ctx)) {
+        return mapping_1.default.mapQueries(ctx);
+    }
+    else {
+        return mapping_1.default.mapQueryExecution(ctx);
+    }
+}
+exports.default = (ctx, next) => __awaiter(void 0, void 0, void 0, function* () {
+    let urlParts = ctx.url.split("/");
+    urlParts = urlParts.slice(4, urlParts.length);
+    let body = {};
+    switch (urlParts[0]) {
+        case Resources.APPLICATION:
+            body = processApplications(ctx);
+            break;
+        case Resources.TABLES:
+            if (urlParts[2] === Resources.ROWS) {
+                body = processRows(ctx);
+            }
+            else {
+                body = processTables(ctx);
+            }
+            break;
+        case Resources.USERS:
+            body = processUsers(ctx);
+            break;
+        case Resources.QUERIES:
+            body = processQueries(ctx);
+            break;
+    }
+    // update the body based on what has occurred in the mapper
+    ctx.body = body;
+    yield next();
+});

package/dist/api/routes/public/queries.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const queries_1 = __importDefault(require("../../controllers/public/queries"));
+const Endpoint_1 = __importDefault(require("./utils/Endpoint"));
+const validators_1 = require("../utils/validators");
+const read = [], write = [];
+/**
+ * @openapi
+ * /queries/{queryId}:
+ *   post:
+ *     summary: Execute a query
+ *     description: Queries which have been created within a Budibase app can be executed using this,
+ *     tags:
+ *       - queries
+ *     parameters:
+ *       - $ref: '#/components/parameters/queryId'
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/executeQuery'
+ *     responses:
+ *       200:
+ *         description: Returns the result of the query execution.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               $ref: '#/components/schemas/executeQueryOutput'
+ *             examples:
+ *               REST:
+ *                 $ref: '#/components/examples/restResponse'
+ *               SQL:
+ *                 $ref: '#/components/examples/sqlResponse'
+ *
+ */
+write.push(new Endpoint_1.default("post", "/queries/:queryId", queries_1.default.execute));
+/**
+ * @openapi
+ * /queries/search:
+ *   post:
+ *     summary: Search for queries
+ *     description: Based on query properties (currently only name) search for queries.
+ *     tags:
+ *       - queries
+ *     parameters:
+ *       - $ref: '#/components/parameters/appId'
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/nameSearch'
+ *     responses:
+ *       200:
+ *         description: Returns the queries found based on the search parameters.
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               required:
+ *                 - data
+ *               properties:
+ *                 data:
+ *                   type: array
+ *                   items:
+ *                     $ref: '#/components/schemas/query'
+ *             examples:
+ *               queries:
+ *                 $ref: '#/components/examples/queries'
+ */
+read.push(new Endpoint_1.default("post", "/queries/search", queries_1.default.search).addMiddleware(validators_1.nameValidator()));
+exports.default = { read, write };