@pgds/api-interface 1.4.0 → 1.4.1

package/constants/index.d.ts

@@ -5,4 +5,5 @@ export declare const AUTH_ACTIVITIES_HEADER = "auth-activities";
 export declare const AUTH_ACTIVE_LOGIN_HEADER = "auth-active-login";
 export declare const GLOBAL_ACTIVITY = "global";
 export declare const CAN_MANAGE_ORGANIZATION_ACTIVITY = "canManageOrganization";
+export declare const CAN_MANAGE_PLATFORM_ACTIVITY = "canManagePlatform";
 export declare const REQUEST_ID_HEADER = "request-id";

package/constants/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.REQUEST_ID_HEADER = exports.CAN_MANAGE_ORGANIZATION_ACTIVITY = exports.GLOBAL_ACTIVITY = exports.AUTH_ACTIVE_LOGIN_HEADER = exports.AUTH_ACTIVITIES_HEADER = exports.AUTH_ORGANIZATION_HIERARCHY_HEADER = exports.AUTH_ORGANIZATION_HEADER = exports.AUTH_USER_HEADER = void 0;
+exports.REQUEST_ID_HEADER = exports.CAN_MANAGE_PLATFORM_ACTIVITY = exports.CAN_MANAGE_ORGANIZATION_ACTIVITY = exports.GLOBAL_ACTIVITY = exports.AUTH_ACTIVE_LOGIN_HEADER = exports.AUTH_ACTIVITIES_HEADER = exports.AUTH_ORGANIZATION_HIERARCHY_HEADER = exports.AUTH_ORGANIZATION_HEADER = exports.AUTH_USER_HEADER = void 0;
 /* Note: These will be exported to the library as @hiotlabs/hiot-api-interface/constants */
 exports.AUTH_USER_HEADER = "auth-user";
 exports.AUTH_ORGANIZATION_HEADER = "auth-organization";
@@ -9,5 +9,6 @@ exports.AUTH_ACTIVITIES_HEADER = "auth-activities";
 exports.AUTH_ACTIVE_LOGIN_HEADER = "auth-active-login";
 exports.GLOBAL_ACTIVITY = "global";
 exports.CAN_MANAGE_ORGANIZATION_ACTIVITY = "canManageOrganization";
+exports.CAN_MANAGE_PLATFORM_ACTIVITY = "canManagePlatform";
 exports.REQUEST_ID_HEADER = "request-id";
 //# sourceMappingURL=index.js.map

package/constants/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAAA,2FAA2F;AAC9E,QAAA,gBAAgB,GAAG,WAAW,CAAC;AAC/B,QAAA,wBAAwB,GAAG,mBAAmB,CAAC;AAC/C,QAAA,kCAAkC,GAAG,6BAA6B,CAAC;AACnE,QAAA,sBAAsB,GAAG,iBAAiB,CAAC;AAC3C,QAAA,wBAAwB,GAAG,mBAAmB,CAAC;AAE/C,QAAA,eAAe,GAAG,QAAQ,CAAC;AAC3B,QAAA,gCAAgC,GAAG,uBAAuB,CAAC;AAE3D,QAAA,iBAAiB,GAAG,YAAY,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;AAAA,2FAA2F;AAC9E,QAAA,gBAAgB,GAAG,WAAW,CAAC;AAC/B,QAAA,wBAAwB,GAAG,mBAAmB,CAAC;AAC/C,QAAA,kCAAkC,GAAG,6BAA6B,CAAC;AACnE,QAAA,sBAAsB,GAAG,iBAAiB,CAAC;AAC3C,QAAA,wBAAwB,GAAG,mBAAmB,CAAC;AAE/C,QAAA,eAAe,GAAG,QAAQ,CAAC;AAC3B,QAAA,gCAAgC,GAAG,uBAAuB,CAAC;AAC3D,QAAA,4BAA4B,GAAG,mBAAmB,CAAC;AAEnD,QAAA,iBAAiB,GAAG,YAAY,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { setupApiInterface, JsonResponse, del, endpointMetadata, get, getRouteHelpers, head, options, patch, post, put, internal, Method } from "./lib";
+import { Next, Request, Response } from "./lib/models/Http";
+import { User } from "./lib/models/User";
+export { endpointMetadata, del, get, getRouteHelpers, head, options, patch, post, put, internal, setupApiInterface, JsonResponse, Request, Response, Next, Method, User, };

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Method = exports.setupApiInterface = exports.internal = exports.put = exports.post = exports.patch = exports.options = exports.head = exports.getRouteHelpers = exports.get = exports.del = exports.endpointMetadata = void 0;
+var lib_1 = require("./lib");
+Object.defineProperty(exports, "setupApiInterface", { enumerable: true, get: function () { return lib_1.setupApiInterface; } });
+Object.defineProperty(exports, "del", { enumerable: true, get: function () { return lib_1.del; } });
+Object.defineProperty(exports, "endpointMetadata", { enumerable: true, get: function () { return lib_1.endpointMetadata; } });
+Object.defineProperty(exports, "get", { enumerable: true, get: function () { return lib_1.get; } });
+Object.defineProperty(exports, "getRouteHelpers", { enumerable: true, get: function () { return lib_1.getRouteHelpers; } });
+Object.defineProperty(exports, "head", { enumerable: true, get: function () { return lib_1.head; } });
+Object.defineProperty(exports, "options", { enumerable: true, get: function () { return lib_1.options; } });
+Object.defineProperty(exports, "patch", { enumerable: true, get: function () { return lib_1.patch; } });
+Object.defineProperty(exports, "post", { enumerable: true, get: function () { return lib_1.post; } });
+Object.defineProperty(exports, "put", { enumerable: true, get: function () { return lib_1.put; } });
+Object.defineProperty(exports, "internal", { enumerable: true, get: function () { return lib_1.internal; } });
+Object.defineProperty(exports, "Method", { enumerable: true, get: function () { return lib_1.Method; } });

package/dist/lib/constants/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const CI: boolean;
+export declare const SCHEMA_BASE_PATH = "api/schemas";

package/dist/lib/index.d.ts

@@ -0,0 +1,188 @@
+/// <reference path="../../types/hiot.d.ts" />
+/// <reference types="node" />
+import fs from "fs";
+import App, { Locator } from "hiot";
+import { RouteOptions } from "restify";
+import { Next, Request, Response } from "./models/Http";
+export declare const readDirAsync: typeof fs.readdir.__promisify__;
+export declare enum Method {
+    Post = "post",
+    Get = "get",
+    Put = "put",
+    Patch = "patch",
+    Del = "del",
+    Head = "head",
+    Options = "options"
+}
+type OmittedFields = "internal" | "method";
+export declare function get(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export declare function post(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export declare function put(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export declare function patch(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export declare function del(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export declare function head(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export declare function options(options: Omit<EndpointOptions, OmittedFields>): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+/** Internal endpoints are not available through the API */
+export declare function internal(options: Omit<EndpointOptions, "internal">): {
+    (api: App): void;
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    requestHandler: (req: Request<any, any>, res?: Response<any> | undefined, next?: Next | undefined) => Promise<void | JsonResponse<any>>;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    PATH: string;
+};
+export interface JsonResponse<T> {
+    /** Response body */
+    body?: T;
+    /** HTTP status code. @default 200 */
+    status?: number;
+    /** Additional headers */
+    headers?: {
+        totalcount?: number;
+        [key: string]: any;
+    };
+}
+export { Next, Request, Response };
+export interface EndpointOptions {
+    /** Whether to add the endpoint to the metadata or not. @default true */
+    addToMetadata?: boolean;
+    /** Whether the endpoint is internal or not */
+    internal?: boolean;
+    /** The path to the endpoint */
+    path: string;
+    /** The activity that is required to access this endpoint */
+    authorized?: string;
+    /** Whether you need to be logged in or not to access the endpoint. Only needed if authorized is not used. */
+    authenticated?: boolean;
+    /** HTTP method */
+    method: Method;
+    /**
+     * The request schema, either a JSON schema or the name of a typescript type
+     * (See below. The name must match the name of the file in ./api/schemas).
+     **/
+    requestSchema?: object | string;
+    /** Additional route options */
+    opts?: RouteOptions;
+    /** prefix for the path, e.g. /v1, defaults to what was set in setupApiInterface */
+    version?: string;
+    /** The documentation for the endpoint */
+    documentation?: {
+        /** Short description of the endpoint */
+        summary: string;
+        /** Long description of the endpoint */
+        description?: string;
+        /** Optional array of tags */
+        tags?: string[];
+        /**
+         * Optional description for query params (can also be defined and described in the json schema,
+         * since that's how we validate them)
+         **/
+        query?: Record<string, string>;
+        /**
+         * Optional description of url parameters.
+         * Usually unnecessary since url params should be self descriptive, e.g. /dashboards/:dashboardId
+         **/
+        parameters?: Record<string, string>;
+        /** Response schemas */
+        responses?: {
+            /** HTTP status code */
+            status: number;
+            /** An optional description of the response */
+            description?: string;
+            /**
+             * An optional response schema, either a JSON schema or the name of a typescript type
+             * (See below. The name must match the name of the file in ./api/schemas).
+             **/
+            schema?: any | any[];
+        }[];
+    };
+    /** The request handler function */
+    requestHandler: (req: Request<any>, res?: Response<any>, next?: Next) => Promise<JsonResponse<any> | void>;
+}
+export type EndpointMetadata = Omit<EndpointOptions, "requestHandler" | "opts">;
+export declare const endpointMetadata: {
+    [key in Method]: Record<string, EndpointMetadata>;
+};
+export declare function getRouteHelpers(): {
+    authenticated: () => App.RequestHandlerType;
+    authorized: (activity: string) => App.RequestHandlerType;
+};
+export interface ApiInterfaceOptions {
+    /** Name of the service */
+    serviceName: string;
+    /** Default log level for the service */
+    serviceLogLevel: string;
+    /** Whether to use typescript or not */
+    typescript: boolean;
+    /** Global version of the API @default v1. Can be overridden per endpoint */
+    apiVersion: string;
+    /** The base path to the schemas. @default api/schemas */
+    schemaBasePath?: string;
+}
+export declare function getApiOptions(): ApiInterfaceOptions;
+export declare function setupApiInterface(options: ApiInterfaceOptions): (locator: Locator) => Promise<App.Locator>;

package/dist/lib/index.js

@@ -0,0 +1,331 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupApiInterface = exports.getApiOptions = exports.getRouteHelpers = exports.endpointMetadata = exports.internal = exports.options = exports.head = exports.del = exports.patch = exports.put = exports.post = exports.get = exports.Method = exports.readDirAsync = void 0;
+var fs_1 = __importDefault(require("fs"));
+var hiot_restify5_1 = require("hiot-restify5");
+var mustbe_1 = __importDefault(require("mustbe"));
+var restify_errors_1 = __importDefault(require("restify-errors"));
+var util_1 = require("util");
+var constants_1 = require("./constants/constants");
+var jsonSchemaUtils_1 = require("./utils/jsonSchemaUtils");
+var logger_1 = __importStar(require("./utils/logger"));
+var urlUtils_1 = require("./utils/urlUtils");
+exports.readDirAsync = (0, util_1.promisify)(fs_1.default.readdir);
+var Method;
+(function (Method) {
+    Method["Post"] = "post";
+    Method["Get"] = "get";
+    Method["Put"] = "put";
+    Method["Patch"] = "patch";
+    Method["Del"] = "del";
+    Method["Head"] = "head";
+    Method["Options"] = "options";
+})(Method || (exports.Method = Method = {}));
+function get(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Get }));
+}
+exports.get = get;
+function post(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Post }));
+}
+exports.post = post;
+function put(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Put }));
+}
+exports.put = put;
+function patch(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Patch }));
+}
+exports.patch = patch;
+function del(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Del }));
+}
+exports.del = del;
+function head(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Head }));
+}
+exports.head = head;
+function options(options) {
+    return registerEndpoint(__assign(__assign({}, options), { method: Method.Options }));
+}
+exports.options = options;
+/** Internal endpoints are not available through the API */
+function internal(options) {
+    return registerEndpoint(__assign(__assign({}, options), { internal: true }));
+}
+exports.internal = internal;
+exports.endpointMetadata = (_a = {},
+    _a[Method.Post] = {},
+    _a[Method.Get] = {},
+    _a[Method.Put] = {},
+    _a[Method.Patch] = {},
+    _a[Method.Del] = {},
+    _a[Method.Head] = {},
+    _a.options = {},
+    _a);
+var metadataRegistered = false;
+function registerMetadataEndpoint(api) {
+    var _this = this;
+    if (metadataRegistered) {
+        return;
+    }
+    metadataRegistered = true;
+    registerEndpoint({
+        path: "/".concat(apiOptions.serviceName, "/metadata"),
+        method: Method.Get,
+        addToMetadata: false,
+        version: "",
+        requestHandler: function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                // prepare metadata here so that we get schemas and not just ids in the response
+                return [2 /*return*/, {
+                        body: exports.endpointMetadata,
+                    }];
+            });
+        }); },
+    })(api);
+}
+var mustBe;
+function getRouteHelpers() {
+    if (!mustBe) {
+        mustBe = mustbe_1.default.routeHelpers();
+    }
+    return mustBe;
+}
+exports.getRouteHelpers = getRouteHelpers;
+function registerEndpoint(options) {
+    var _this = this;
+    var _a;
+    var requestHandler = options.requestHandler, opts = options.opts, _b = options.addToMetadata, addToMetadata = _b === void 0 ? true : _b, metadata = __rest(options, ["requestHandler", "opts", "addToMetadata"]);
+    if (!constants_1.CI) {
+        if (addToMetadata) {
+            exports.endpointMetadata[options.method][options.path] = metadata;
+        }
+    }
+    var fn = function (api) {
+        // registerMetadataEndpoint(api);
+        var _a;
+        var mustBe = getRouteHelpers();
+        var routeOptions = {
+            path: (0, urlUtils_1.route)((_a = options.version) !== null && _a !== void 0 ? _a : apiVersion, options.path, options.internal),
+        };
+        if (options.opts) {
+            routeOptions = __assign(__assign({}, routeOptions), options.opts);
+        }
+        var requestHandlers = [];
+        if (options.authenticated) {
+            requestHandlers.push(mustBe.authenticated());
+        }
+        if (options.authorized) {
+            requestHandlers.push(mustBe.authorized(options.authorized));
+        }
+        if (options.requestSchema) {
+            var schema = options.requestSchema;
+            if (typeof schema === "string") {
+                schema = (0, jsonSchemaUtils_1.getSchema)(schema);
+            }
+            try {
+                var validatedSchema = (0, hiot_restify5_1.validate)(schema);
+                requestHandlers.push(validatedSchema);
+            }
+            catch (err) {
+                console.error(err);
+                throw err;
+            }
+        }
+        var responseSchemas = [];
+        if (constants_1.CI) {
+            responseSchemas = (0, jsonSchemaUtils_1.prepareResponseSchemas)(options);
+        }
+        requestHandlers.push(function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
+            var response, header, err_1;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        _c.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, options.requestHandler(req, res, next)];
+                    case 1:
+                        response = _c.sent();
+                        if (response) {
+                            res.statusCode = (_a = response.status) !== null && _a !== void 0 ? _a : 200;
+                            if (response.headers) {
+                                for (header in response.headers) {
+                                    res.header(header, response.headers[header]);
+                                }
+                            }
+                            if (response.body) {
+                                if (constants_1.CI && !!responseSchemas.length) {
+                                    (0, jsonSchemaUtils_1.validateResponseBody)(responseSchemas, response.body);
+                                }
+                                res.json(response.body);
+                            }
+                            else {
+                                res.end();
+                            }
+                        }
+                        return [2 /*return*/, next()];
+                    case 2:
+                        err_1 = _c.sent();
+                        if ((_b = err_1 === null || err_1 === void 0 ? void 0 : err_1.body) === null || _b === void 0 ? void 0 : _b.code) {
+                            if (constants_1.CI) {
+                                console.error(err_1.toString());
+                            }
+                            else {
+                                logger_1.default.error(err_1);
+                            }
+                            return [2 /*return*/, next(err_1)];
+                        }
+                        if (constants_1.CI) {
+                            console.error(err_1.toString ? err_1.toString() : err_1);
+                        }
+                        else {
+                            logger_1.default.error(err_1);
+                        }
+                        return [2 /*return*/, next(new restify_errors_1.default.InternalError(err_1))];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); });
+        var pendingRoute = {
+            method: options.method,
+            opts: routeOptions,
+            handlers: requestHandlers,
+        };
+        // @ts-ignore
+        api[pendingRoute.method].apply(api, __spreadArray([pendingRoute.opts], pendingRoute.handlers, false));
+    };
+    /**
+     * Makes it possible to access the requestHandler through the exported function.
+     * If you need to test the function separately, without starting the server
+     */
+    fn.requestHandler = options.requestHandler;
+    /** Endpoint's full path (including any version number and internal prefix) */
+    fn.PATH = (0, urlUtils_1.route)((_a = options.version) !== null && _a !== void 0 ? _a : apiVersion, options.path, options.internal);
+    return fn;
+}
+var apiVersion = "v1";
+var apiOptions = {};
+function getApiOptions() {
+    return apiOptions;
+}
+exports.getApiOptions = getApiOptions;
+function setupApiInterface(options) {
+    var _this = this;
+    apiOptions = options;
+    return function (locator) { return __awaiter(_this, void 0, void 0, function () {
+        var files;
+        var _a;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    if (!(options.typescript &&
+                        /** This check is only applicable during tests, so it's only run once */
+                        jsonSchemaUtils_1.schemaCache.size === 0)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, (0, exports.readDirAsync)((_a = options.schemaBasePath) !== null && _a !== void 0 ? _a : constants_1.SCHEMA_BASE_PATH)];
+                case 1:
+                    files = _b.sent();
+                    (0, jsonSchemaUtils_1.getSchemas)(files.map(function (file) { return file.replace(".ts", ""); }));
+                    _b.label = 2;
+                case 2:
+                    (0, logger_1.setupLogger)(options.serviceName, options.serviceLogLevel);
+                    return [2 /*return*/, locator];
+            }
+        });
+    }); };
+}
+exports.setupApiInterface = setupApiInterface;

package/dist/lib/models/Http.d.ts

@@ -0,0 +1,61 @@
+import { User } from "./User";
+import { Request as RestifyRequest, Response as RestifyResponse, Next as RestifyNext } from "restify";
+export interface Request<BodyParams = Record<string, any>, QueryParams = any> extends RestifyRequest {
+    params: BodyParams;
+    user: User;
+    query: QueryParams;
+}
+export interface Next extends RestifyNext {
+    (err?: any): void;
+}
+export interface Response<Body = Record<string, any>> extends RestifyResponse {
+    /**
+     * short hand method for:
+     *     res.contentType = 'json';
+     *     res.send({hello: 'world'});
+     * @param    code    http status code
+     * @param    body    value to json.stringify
+     * @param    [headers] headers to set on the response
+     */
+    json(code: number, body: Body, headers?: {
+        [header: string]: string;
+    }): any;
+    /**
+     * short hand method for:
+     *     res.contentType = 'json';
+     *     res.send({hello: 'world'});
+     * @param    code    http status code
+     */
+    json(code: number): any;
+    /**
+     * short hand method for:
+     *     res.contentType = 'json';
+     *     res.send({hello: 'world'});
+     * @param    body    value to json.stringify
+     * @param    [headers] headers to set on the response
+     */
+    json(body: Body, headers?: {
+        [header: string]: string;
+    }): any;
+    /**
+     * sends the response object. pass through to internal __send that uses a
+     * formatter based on the content-type header.
+     * @param    [code] http status code
+     * @param    [body] the content to send
+     * @param    [headers]  any add'l headers to set
+     * @returns  the response object
+     */
+    send(code?: number, body?: Body, headers?: {
+        [header: string]: string;
+    }): any;
+    /**
+     * sends the response object. pass through to internal __send that uses a
+     * formatter based on the content-type header.
+     * @param    [body] the content to send
+     * @param    [headers]  any add'l headers to set
+     * @returns  the response object
+     */
+    send(body?: Body, headers?: {
+        [header: string]: string;
+    }): any;
+}

package/dist/lib/models/User.d.ts

@@ -0,0 +1,8 @@
+export interface User {
+    userId: string;
+    name: string;
+    cellPhones: string | string[];
+    status: string;
+    activities: Record<string, string>;
+    organizationId: string;
+}

package/dist/lib/utils/jsonSchemaUtils.d.ts

@@ -0,0 +1,7 @@
+import { EndpointOptions } from "..";
+/** Speeds up loading schemas when testing by only loading the schemas once instead of once per test file */
+export declare const schemaCache: Map<string, object>;
+export declare function getSchemas(schemaNames: string[]): void;
+export declare function getSchema(schemaName: string): object | undefined;
+export declare function prepareResponseSchemas(options: EndpointOptions): object[];
+export declare function validateResponseBody(schemas: object[], body: object): void;

package/dist/lib/utils/logger.d.ts

@@ -0,0 +1,4 @@
+import bunyan from "bunyan";
+export declare function setupLogger(inServiceName: string, inServiceLogLevel: string): void;
+declare const _default: bunyan;
+export default _default;

package/dist/lib/utils/metadataUtils.d.ts

@@ -0,0 +1,2 @@
+import { EndpointMetadata, EndpointOptions } from "..";
+export declare function prepareMetadata(options: EndpointOptions, metadata: EndpointMetadata): EndpointMetadata;

package/dist/lib/utils/urlUtils.d.ts

@@ -0,0 +1 @@
+export declare function route(version: string, path: string, internal?: boolean): string;

package/package.json

@@ -1,101 +1,101 @@
 {
-    "name": "@pgds/api-interface",
-    "description": "Api interface for pgds services",
-    "authors": "Florry",
-    "version": "1.4.0",
-    "main": "index.js",
-    "types": "types/",
-    "scripts": {
-        "prepublish": "npm run build",
-        "build": "tsc",
-        "pretest": "npm run build",
-        "test": "nyc --require ts-node/register --reporter=html mocha --colors",
-        "clean": "git clean -f -x -e node_modules/ -e coverage/"
-    },
-    "files": [
-        "**/*.d.ts",
-        "./index.js",
-        "lib/**/*.js",
-        "lib/**/*.js.map",
-        "lib/**/*.d.ts",
-        "errors/**/*.js",
-        "errors/**/*.js.map",
-        "errors/**/*.d.ts",
-        "constants/**/*.js",
-        "constants/**/*.js.map",
-        "constants/**/*.d.ts",
-        "utils/**/*.js",
-        "utils/**/*.js.map",
-        "utils/**/*.d.ts",
-        "client/**/*.js",
-        "client/**/*.js.map",
-        "client/**/*.d.ts"
+  "name": "@pgds/api-interface",
+  "description": "Api interface for pgds services",
+  "authors": "Florry",
+  "version": "1.4.1",
+  "main": "index.js",
+  "types": "types/",
+  "scripts": {
+    "prepublish": "npm run build",
+    "build": "tsc",
+    "pretest": "npm run build",
+    "test": "nyc --require ts-node/register --reporter=html mocha --colors",
+    "clean": "git clean -f -x -e node_modules/ -e coverage/"
+  },
+  "files": [
+    "**/*.d.ts",
+    "./index.js",
+    "lib/**/*.js",
+    "lib/**/*.js.map",
+    "lib/**/*.d.ts",
+    "errors/**/*.js",
+    "errors/**/*.js.map",
+    "errors/**/*.d.ts",
+    "constants/**/*.js",
+    "constants/**/*.js.map",
+    "constants/**/*.d.ts",
+    "utils/**/*.js",
+    "utils/**/*.js.map",
+    "utils/**/*.d.ts",
+    "client/**/*.js",
+    "client/**/*.js.map",
+    "client/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@types/restify": "^8.5.12",
+    "@types/restify-errors": "^4.3.9",
+    "@pgds/utils": "1.0.7",
+    "ajv": "8.17.1",
+    "ajv-formats": "3.0.1",
+    "axios": "1.7.9",
+    "mustbe": "0.4.0",
+    "nyc": "^17.1.0",
+    "prom-client": "^12.0.0",
+    "restify": "^11.1.0",
+    "restify-errors": "8.0.2",
+    "semver": "^7.3.8",
+    "ts-node": "^10.9.2",
+    "ts-node-test-register": "^10.0.0",
+    "uuid": "9.0.1",
+    "typescript": "^5.7.2",
+    "typescript-json-schema": "0.65.1"
+  },
+  "devDependencies": {
+    "@types/chai": "4.3.12",
+    "@types/mocha": "^10.0.6",
+    "@types/mockery": "^1.4.30",
+    "@types/nock": "11.1.0",
+    "@types/semver": "^7.3.13",
+    "@types/supertest": "^2.0.11",
+    "@types/uuid": "^8.3.4",
+    "chai": "^4.3.6",
+    "chai-subset": "^1.6.0",
+    "mocha": "10.2.0",
+    "mockery": "2.1.0",
+    "supertest": "6.3.4",
+    "nock": "13.5.5"
+  },
+  "directories": {
+    "example": "examples",
+    "lib": "lib",
+    "types": "types"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hiotlabs/hiot-api-interface.git"
+  },
+  "keywords": [
+    "restify"
+  ],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/hiotlabs/hiot-api-interface/issues"
+  },
+  "homepage": "https://github.com/hiotlabs/hiot-api-interface#readme",
+  "mocha": {
+    "extension": [
+      "ts",
+      "js"
     ],
-    "dependencies": {
-        "@types/restify": "^8.5.12",
-        "@types/restify-errors": "^4.3.9",
-        "@pgds/utils": "1.0.7",
-        "ajv": "8.17.1",
-        "ajv-formats": "3.0.1",
-        "axios": "1.7.9",
-        "mustbe": "0.4.0",
-        "nyc": "^17.1.0",
-        "prom-client": "^12.0.0",
-        "restify": "^11.1.0",
-        "restify-errors": "8.0.2",
-        "semver": "^7.3.8",
-        "ts-node": "^10.9.2",
-        "ts-node-test-register": "^10.0.0",
-        "uuid": "9.0.1",
-        "typescript": "^5.7.2",
-        "typescript-json-schema": "0.65.1"
-    },
-    "devDependencies": {
-        "@types/chai": "4.3.12",
-        "@types/mocha": "^10.0.6",
-        "@types/mockery": "^1.4.30",
-        "@types/nock": "11.1.0",
-        "@types/semver": "^7.3.13",
-        "@types/supertest": "^2.0.11",
-        "@types/uuid": "^8.3.4",
-        "chai": "^4.3.6",
-        "chai-subset": "^1.6.0",
-        "mocha": "10.2.0",
-        "mockery": "2.1.0",
-        "supertest": "6.3.4",
-        "nock": "13.5.5"
-    },
-    "directories": {
-        "example": "examples",
-        "lib": "lib",
-        "types": "types"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/hiotlabs/hiot-api-interface.git"
-    },
-    "keywords": [
-        "restify"
-    ],
-    "author": "",
-    "license": "ISC",
-    "bugs": {
-        "url": "https://github.com/hiotlabs/hiot-api-interface/issues"
-    },
-    "homepage": "https://github.com/hiotlabs/hiot-api-interface#readme",
-    "mocha": {
-        "extension": [
-            "ts",
-            "js"
-        ],
-        "spec": "test/**/*.test.{ts,js}"
-    },
-    "nyc": {
-        "exclude": [
-            "coverage",
-            "test",
-            "**/*.d.ts",
-            "**/*.js.map"
-        ]
-    }
-}
+    "spec": "test/**/*.test.{ts,js}"
+  },
+  "nyc": {
+    "exclude": [
+      "coverage",
+      "test",
+      "**/*.d.ts",
+      "**/*.js.map"
+    ]
+  }
+}