@terreno/api 0.6.0 → 0.7.1

package/dist/vendor/wesleytodd-openapi/lib/generate-doc.js

@@ -0,0 +1,148 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: main / tag: v1.1.0)
+// NOTE: This file uses the main-branch algorithm (regexp-based route traversal) rather than
+// the express-5 branch version, because the express-5 version requires router.getRoutes()
+// which only exists on the bjohansebas/router fork and not on the Express 5 app router.
+// The main-branch approach works correctly with the openApiCompat.ts regexp shim.
+// License: ISC (see ../LICENSE)
+'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 pathToRegexp = require('path-to-regexp');
+var minimumViableDocument = require('./minimum-doc');
+var _a = require('./layer-schema'), getSchema = _a.get, setSchema = _a.set;
+module.exports = function generateDocument(baseDocument, router, basePath) {
+    // Merge document with select minimum defaults
+    var doc = Object.assign({
+        openapi: minimumViableDocument.openapi
+    }, baseDocument, {
+        info: Object.assign({}, minimumViableDocument.info, baseDocument.info),
+        paths: Object.assign({}, minimumViableDocument.paths, baseDocument.paths)
+    });
+    // Iterate the middleware stack and add any paths and schemas, etc
+    router && router.stack.forEach(function (_layer) {
+        iterateStack('', null, _layer, function (path, routeLayer, layer) {
+            if (basePath && path.startsWith(basePath)) {
+                path = path.replace(basePath, '');
+            }
+            var schema = getSchema(layer.handle);
+            if (!schema || !layer.method) {
+                return;
+            }
+            var operation = Object.assign({}, schema);
+            // Add route params to schema
+            if (routeLayer && routeLayer.keys && routeLayer.keys.length) {
+                var keys_1 = {};
+                var params_1 = routeLayer.keys.map(function (k, i) {
+                    var prev = i > 0 && routeLayer.keys[i - 1];
+                    // do not count parameters without a name if they are next to a named parameter
+                    if (typeof k.name === 'number' && prev && prev.offset + prev.name.length + 1 >= k.offset) {
+                        return null;
+                    }
+                    var param;
+                    if (schema.parameters) {
+                        param = schema.parameters.find(function (p) { return p.name === k.name && p.in === 'path'; });
+                    }
+                    // Reformat the path
+                    keys_1[k.name] = '{' + k.name + '}';
+                    return Object.assign({
+                        name: k.name,
+                        in: 'path',
+                        required: !k.optional,
+                        schema: k.schema || { type: 'string' }
+                    }, param || {});
+                })
+                    .filter(function (e) { return e; });
+                if (schema.parameters) {
+                    schema.parameters.forEach(function (p) {
+                        if (!params_1.find(function (pp) { return p.name === pp.name; })) {
+                            params_1.push(p);
+                        }
+                    });
+                }
+                operation.parameters = params_1;
+                path = pathToRegexp.compile(path.replace(/\*|\(\*\)/g, '(.*)'))(keys_1, { encode: function (value) { return value; } });
+            }
+            doc.paths[path] = doc.paths[path] || {};
+            doc.paths[path][layer.method] = operation;
+            setSchema(layer.handle, operation);
+        });
+    });
+    return doc;
+};
+function iterateStack(path, routeLayer, layer, cb) {
+    cb(path, routeLayer, layer);
+    if (layer.name === 'router') {
+        layer.handle.stack.forEach(function (l) {
+            path = path || '';
+            iterateStack(path + split(layer.regexp, layer.keys).join('/'), layer, l, cb);
+        });
+    }
+    if (!layer.route) {
+        return;
+    }
+    if (Array.isArray(layer.route.path)) {
+        var r_1 = layer.regexp.toString();
+        layer.route.path.forEach(function (p, i) { return iterateStack(path + p, layer, __assign(__assign({}, layer), { 
+            // Checking if p is a string here since p may be a regex expression
+            keys: layer.keys.filter(function (k) { return typeof p === 'string' ? p.includes("/:".concat(k.name)) : false; }), 
+            // There may be an issue here if the regex has a '|', but that seems to only be the case with user defined regex
+            regexp: new RegExp("(".concat(r_1.substring(2, r_1.length - 3).split('|')[i], ")")), route: __assign(__assign({}, layer.route), { path: '' }) }), cb); });
+        return;
+    }
+    layer.route.stack.forEach(function (l) { return iterateStack(path + layer.route.path, layer, l, cb); });
+}
+function processComplexMatch(thing, keys) {
+    var i = 0;
+    return thing
+        .toString()
+        // The replace below replaces the regex used by Express to match dynamic parameters
+        // (i.e. /:id, /:name, etc...) with the name(s) of those parameter(s)
+        // This could have been accomplished with replaceAll for Node version 15 and above
+        // no-useless-escape is disabled since we need three backslashes
+        .replace(/\(\?\:\(\[\^\\\/\]\+\?\)\)/g, function () { return "{".concat(keys[i++].name, "}"); }) // eslint-disable-line no-useless-escape
+        .replace(/\\(.)/g, '$1')
+        // The replace below removes the regex used at the start of the string and
+        // the regex used to match the query parameters
+        .replace(/\/\^|\/\?(.*)/g, '')
+        .split('/');
+}
+// https://github.com/expressjs/express/issues/3308#issuecomment-300957572
+function split(thing, keys) {
+    // In express v5 the router layers regexp (path-to-regexp@3.2.0)
+    // has some additional handling for end of lines, remove those
+    //
+    // layer.regexp
+    // v4 ^\\/sub-route\\/?(?=\\/|$)
+    // v5 ^\\/sub-route(?:\\/(?=$))?(?=\\/|$)
+    //
+    // l.regexp
+    // v4 ^\\/endpoint\\/?$
+    // v5 ^\\/endpoint(?:\\/)?$
+    if (typeof thing === 'string') {
+        return thing.split('/');
+    }
+    else if (thing.fast_slash) {
+        return [];
+    }
+    else {
+        var match = thing
+            .toString()
+            .replace('\\/?', '')
+            .replace('(?=\\/|$)', '$')
+            // Added this line to catch the express v5 case after the v4 part is stripped off
+            .replace('(?:\\/(?=$))?$', '$')
+            .match(/^\/\^((?:\\[.*+?^${}()|[\]\\/]|[^.*+?^${}()|[\]\\/])*)\$\//);
+        return match
+            ? match[1].replace(/\\(.)/g, '$1').split('/')
+            : processComplexMatch(thing, keys);
+    }
+}

package/dist/vendor/wesleytodd-openapi/lib/layer-schema.d.ts

@@ -0,0 +1,2 @@
+export function set(handler: any, schema: any): void;
+export function get(handler: any): any;

package/dist/vendor/wesleytodd-openapi/lib/layer-schema.js

@@ -0,0 +1,12 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+'use strict';
+var schemas = new Map();
+module.exports = {
+    set: function (handler, schema) {
+        schemas.set(handler, schema);
+    },
+    get: function (handler) {
+        return schemas.get(handler);
+    }
+};

package/dist/vendor/wesleytodd-openapi/lib/minimum-doc.d.ts

@@ -0,0 +1,6 @@
+export let openapi: string;
+export namespace info {
+    let title: string;
+    let version: string;
+}
+export let paths: {};

package/dist/vendor/wesleytodd-openapi/lib/minimum-doc.js

@@ -0,0 +1,11 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+'use strict';
+module.exports = {
+    openapi: '3.0.0',
+    info: {
+        title: 'Express App',
+        version: '1.0.0'
+    },
+    paths: {}
+};

package/dist/vendor/wesleytodd-openapi/lib/ui.d.ts

@@ -0,0 +1 @@
+export function serveSwaggerUI(documentUrl: any, opts?: {}): any[];

package/dist/vendor/wesleytodd-openapi/lib/ui.js

@@ -0,0 +1,37 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+'use strict';
+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 path = require('path');
+var serve = require('serve-static');
+module.exports.serveSwaggerUI = function serveSwaggerUI(documentUrl, opts) {
+    if (opts === void 0) { opts = {}; }
+    var plugins = opts.plugins, options = __rest(opts, ["plugins"]);
+    return [serve(path.resolve(require.resolve('swagger-ui-dist'), '..'), { index: false }),
+        function returnUiInit(req, res, next) {
+            if (req.path.endsWith('/swagger-ui-init.js')) {
+                res.type('.js');
+                res.send("window.onload = function () {\n  window.ui = SwaggerUIBundle({\n    url: '".concat(documentUrl, "',\n    dom_id: '#swagger-ui',\n    ").concat((plugins === null || plugins === void 0 ? void 0 : plugins.length) ? "plugins: [".concat(plugins, "],") : '', "\n    ...").concat(JSON.stringify(options), "\n  })\n}"));
+            }
+            else {
+                next();
+            }
+        },
+        function renderSwaggerHtml(req, res) {
+            res.type('html').send(renderHtmlPage('Swagger UI', "\n      <link rel=\"stylesheet\" type=\"text/css\" href=\"./swagger-ui.css\" >\n    ", "\n      <div id=\"swagger-ui\"></div>\n      <script src=\"./swagger-ui-bundle.js\"></script>\n      <script src=\"./swagger-ui-standalone-preset.js\"></script>\n      <script src=\"./swagger-ui-init.js\"></script>\n    "));
+        }
+    ];
+};
+function renderHtmlPage(title, head, body) {
+    return "<!DOCTYPE html>\n<html>\n  <head>\n    <title>".concat(title, "</title>\n    <meta charset=\"utf-8\"/>\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n    <style>\n      html {\n          box-sizing: border-box;\n          overflow: -moz-scrollbars-vertical;\n          overflow-y: scroll;\n      }\n      *,\n      *:before,\n      *:after {\n          box-sizing: inherit;\n      }\n      body {\n        margin: 0;\n        padding: 0;\n        background: #fafafa;\n      }\n    </style>\n    ").concat(head, "\n  </head>\n  <body>\n    ").concat(body, "\n  </body>\n</html>\n  ");
+}

package/dist/vendor/wesleytodd-openapi/lib/validate.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(middleware: any, schema: any, opts: any): (req: any, res: any, next: any) => any;
+export = _exports;

package/dist/vendor/wesleytodd-openapi/lib/validate.js

@@ -0,0 +1,168 @@
+// Vendored from https://github.com/wesleytodd/express-openapi (branch: express-5)
+// License: ISC (see ../LICENSE)
+'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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var Ajv = require('ajv');
+var addFormats = require('ajv-formats');
+var addKeywords = require('ajv-keywords');
+var httpErrors = require('http-errors');
+var BASE_REQ_SCHEMA = {
+    type: 'object',
+    required: ['headers', 'params', 'query'],
+    properties: {
+        headers: {
+            type: 'object',
+            required: [],
+            properties: {}
+        },
+        params: {
+            type: 'object',
+            required: [],
+            properties: {}
+        },
+        query: {
+            type: 'object',
+            required: [],
+            properties: {}
+        },
+        body: {
+            type: 'object',
+            required: [],
+            properties: {}
+        }
+    }
+};
+module.exports = function makeValidatorMiddleware(middleware, schema, opts) {
+    var ajv;
+    var validate;
+    function makeValidator() {
+        var reqSchema = structuredClone(BASE_REQ_SCHEMA);
+        // Compile req schema on first request
+        // Build param validation
+        schema.parameters && schema.parameters.forEach(function (p) {
+            switch (p.in) {
+                case 'path':
+                    reqSchema.properties.params.properties[p.name] = p.schema;
+                    p.required && !reqSchema.properties.params.required.includes(p.name) && reqSchema.properties.params.required.push(p.name);
+                    break;
+                case 'query':
+                    reqSchema.properties.query.properties[p.name] = p.schema;
+                    p.required && !reqSchema.properties.query.required.includes(p.name) && reqSchema.properties.query.required.push(p.name);
+                    break;
+                case 'header': {
+                    var name_1 = p.name.toLowerCase();
+                    reqSchema.properties.headers.properties[name_1] = p.schema;
+                    p.required && !reqSchema.properties.headers.required.includes(p.name) && reqSchema.properties.headers.required.push(name_1);
+                    break;
+                }
+            }
+        });
+        // Compile req body schema
+        schema.requestBody && Object.entries(schema.requestBody.content)
+            .forEach(function (_a) {
+            var _b = __read(_a, 2), contentType = _b[0], schema = _b[1].schema;
+            switch (contentType) {
+                case 'application/json':
+                    reqSchema.properties.body = schema;
+                    break;
+                default:
+                    throw new TypeError("Validation of content type not supported: ".concat(contentType));
+            }
+        });
+        // Add components for references
+        reqSchema.components = middleware.document && middleware.document.components;
+        return ajv.compile(reqSchema);
+    }
+    return function validateMiddleware(req, res, next) {
+        // Restrict validation to only "route" layers
+        // This prevents running any validation
+        // if we are in a .use call which could
+        // be a non-routable request thus
+        if (!req.route) {
+            return next();
+        }
+        // Create ajv instance on first request
+        if (!ajv) {
+            ajv = new Ajv({
+                coerceTypes: opts.coerce === 'false' ? opts.coerce : true,
+                strict: opts.strict === true ? opts.strict : false
+            });
+            addFormats(ajv);
+            if (middleware.router && !middleware.router.handle) {
+                return next();
+            }
+            if (opts.keywords) {
+                addKeywords(ajv, opts.keywords);
+            }
+        }
+        if (!validate) {
+            validate = makeValidator();
+        }
+        // Validate request
+        var r = req;
+        if (opts.coerce !== true) {
+            r = makeReqCopy(req);
+        }
+        else {
+            // Redifine query and params as normal objects we can write to, so we can coerce the data
+            Object.defineProperty(req, 'query', {
+                value: __assign({}, req.query),
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+            Object.defineProperty(req, 'params', {
+                value: __assign({}, req.params),
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+        var validationStatus = validate(r);
+        if (validationStatus === true) {
+            return next();
+        }
+        // build error?
+        var err = new Error('Request validation failed');
+        err.validationErrors = validate.errors;
+        err.validationSchema = validate.schema;
+        next(httpErrors(400, err));
+    };
+};
+// This is because ajv modifies the original data,
+// preventing this requires that we dont pass the
+// actual req.  An issue has been opened (@TODO open the issue)
+function makeReqCopy(req) {
+    return JSON.parse(JSON.stringify({
+        headers: req.headers,
+        params: req.params,
+        query: req.query,
+        body: req.body
+    }));
+}

package/dist/versionCheckPlugin.d.ts

@@ -0,0 +1,15 @@
+import type express from "express";
+import type { TerrenoPlugin } from "./terrenoPlugin";
+export type VersionCheckStatus = "ok" | "warning" | "required";
+export interface VersionCheckResponse {
+    message?: string;
+    status: VersionCheckStatus;
+    updateUrl?: string;
+}
+/**
+ * TerrenoPlugin that adds a public GET /version-check endpoint for upgrade enforcement.
+ * Compares client build number against admin-configured thresholds per platform.
+ */
+export declare class VersionCheckPlugin implements TerrenoPlugin {
+    register(app: express.Application): void;
+}

package/dist/versionCheckPlugin.js

@@ -0,0 +1,106 @@
+"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 __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 = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VersionCheckPlugin = void 0;
+var api_1 = require("./api");
+var versionConfig_1 = require("./models/versionConfig");
+var DEFAULT_WARNING_MESSAGE = "A new version is available. Please update for the best experience.";
+var DEFAULT_REQUIRED_MESSAGE = "This version is no longer supported. Please update to continue.";
+/**
+ * TerrenoPlugin that adds a public GET /version-check endpoint for upgrade enforcement.
+ * Compares client build number against admin-configured thresholds per platform.
+ */
+var VersionCheckPlugin = /** @class */ (function () {
+    function VersionCheckPlugin() {
+    }
+    VersionCheckPlugin.prototype.register = function (app) {
+        var _this = this;
+        app.get("/version-check", (0, api_1.asyncHandler)(function (req, res) { return __awaiter(_this, void 0, void 0, function () {
+            var versionParam, platform, version, platformNormalized, config, requiredVersion, warningVersion, response;
+            var _a, _b, _c, _d, _e, _f;
+            return __generator(this, function (_g) {
+                switch (_g.label) {
+                    case 0:
+                        versionParam = req.query.version;
+                        platform = req.query.platform;
+                        version = typeof versionParam === "string"
+                            ? parseInt(versionParam, 10)
+                            : typeof versionParam === "number"
+                                ? versionParam
+                                : undefined;
+                        if (version === undefined || Number.isNaN(version)) {
+                            return [2 /*return*/, res.json({ status: "ok" })];
+                        }
+                        platformNormalized = platform === "web" || platform === "mobile" ? platform : "web";
+                        return [4 /*yield*/, versionConfig_1.VersionConfig.findOneOrNone({ _singleton: "config" })];
+                    case 1:
+                        config = _g.sent();
+                        if (!config) {
+                            return [2 /*return*/, res.json({ status: "ok" })];
+                        }
+                        requiredVersion = platformNormalized === "web"
+                            ? ((_a = config.webRequiredVersion) !== null && _a !== void 0 ? _a : 0)
+                            : ((_b = config.mobileRequiredVersion) !== null && _b !== void 0 ? _b : 0);
+                        warningVersion = platformNormalized === "web"
+                            ? ((_c = config.webWarningVersion) !== null && _c !== void 0 ? _c : 0)
+                            : ((_d = config.mobileWarningVersion) !== null && _d !== void 0 ? _d : 0);
+                        response = {
+                            status: "ok",
+                        };
+                        if (requiredVersion > 0 && version < requiredVersion) {
+                            response.status = "required";
+                            response.message = (_e = config.requiredMessage) !== null && _e !== void 0 ? _e : DEFAULT_REQUIRED_MESSAGE;
+                            if (config.updateUrl) {
+                                response.updateUrl = config.updateUrl;
+                            }
+                        }
+                        else if (warningVersion > 0 && version < warningVersion) {
+                            response.status = "warning";
+                            response.message = (_f = config.warningMessage) !== null && _f !== void 0 ? _f : DEFAULT_WARNING_MESSAGE;
+                            if (config.updateUrl) {
+                                response.updateUrl = config.updateUrl;
+                            }
+                        }
+                        return [2 /*return*/, res.json(response)];
+                }
+            });
+        }); }));
+    };
+    return VersionCheckPlugin;
+}());
+exports.VersionCheckPlugin = VersionCheckPlugin;

package/package.json

@@ -5,13 +5,20 @@
   },
   "dependencies": {
     "@sentry/bun": "^10.25.0",
-    "better-auth": "^1.2.8",
     "@sentry/profiling-node": "^10.25.0",
     "@types/qs": "^6.14.0",
-    "@wesleytodd/openapi": "^1.1.0",
     "ajv": "8.18.0",
     "ajv-formats": "^3.0.1",
+    "ajv-keywords": "^5.1.0",
+    "http-errors": "^2.0.0",
+    "path-to-regexp": "^6.3.0",
+    "router": "^2.2.0",
+    "serve-static": "^1.15.0",
+    "swagger-parser": "^10.0.3",
+    "swagger-ui-dist": "^5.11.8",
+    "yaml": "^2.4.0",
     "axios": "^1.13.2",
+    "better-auth": "^1.2.8",
     "cors": "^2.8.5",
     "cron": "^4.3.4",
     "expo-server-sdk": "^6.0.0",
@@ -93,5 +100,5 @@
     "updateSnapshot": "bun test --update-snapshots"
   },
   "types": "dist/index.d.ts",
-  "version": "0.6.0"
+  "version": "0.7.1"
 }