fastify-txstate 3.2.12 → 3.2.14

package/lib/index.js

@@ -18,6 +18,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prodLogger = exports.devLogger = void 0;
+const ajv_1 = __importDefault(require("ajv"));
 const swagger_1 = __importDefault(require("@fastify/swagger"));
 const swagger_ui_1 = __importDefault(require("@fastify/swagger-ui"));
 const fastify_shared_1 = require("@txstate-mws/fastify-shared");
@@ -117,27 +118,46 @@ class Server {
             if (missingResponse) {
                 newSchema.response['200'] = {
                     description: 'Success. Return type has not been specified.',
-                    type: 'null'
+                    type: 'object'
                 };
             }
             route.schema = newSchema;
         });
-        /**
-         * Fastify validates response schema while serializing the response
-         *
-         * This is great, but because Ajv treats optional properties as non-nullable, optional
-         * properties that are set to `null` instead of `undefined` will fail validation (or with `coerceTypes`,
-         * be converted to empty string or 0 or false). This is silly behavior, so we're adding a hook to
-         * convert all nulls to undefined before fastify validates.
-         */
-        this.app.addHook('preSerialization', async (req, res, payload) => {
-            return req.routeSchema?.response ? (0, txstate_utils_1.destroyNulls)(payload) : payload;
+        this.app.addHook('preValidation', (req, res, done) => {
+            if (req.body != null && req.routeOptions.schema?.body)
+                (0, txstate_utils_1.destroyNulls)(req.body);
+            done();
+        });
+        // use Ajv to validate responses instead of @fastify/json-fast-stringify since ajv does
+        // a better job with recursive types and we don't want to have different behavior between
+        // input and output validation
+        const ajv = new ajv_1.default(config.ajv.customOptions);
+        for (const pluginConfig of config.ajv.plugins ?? []) {
+            const [plugin, opts] = (0, txstate_utils_1.toArray)(pluginConfig);
+            plugin(ajv, opts);
+        }
+        this.app.setSerializerCompiler((route) => {
+            const schema = route.schema;
+            const validate = schema == null ? ajv.compile({ type: 'object' }) : ajv.compile(schema);
+            return data => {
+                /**
+                 * Ajv unfortunately treats optional properties as non-nullable, so they're allowed to
+                 * be undefined but not allowed to be null. Worse, with `coerceTypes`, null will be converted
+                 * to empty string or 0 or false. This is silly behavior, so we're converting all nulls to
+                 * undefined before we validate.
+                 */
+                if (schema != null)
+                    (0, txstate_utils_1.destroyNulls)(data);
+                if (!validate(data))
+                    throw new Error('Output validation failed: ' + validate.errors?.[0].message);
+                return JSON.stringify(data);
+            };
         });
         if (!config.skipOriginCheck && !process.env.SKIP_ORIGIN_CHECK) {
             this.setValidOrigins([...(config.validOrigins ?? []), ...(process.env.VALID_ORIGINS?.split(',') ?? [])]);
             this.setValidOriginHosts([...(config.validOriginHosts ?? []), ...(process.env.VALID_ORIGIN_HOSTS?.split(',') ?? [])]);
             this.setValidOriginSuffixes([...(config.validOriginSuffixes ?? []), ...(process.env.VALID_ORIGIN_SUFFIXES?.split(',') ?? [])]);
-            this.app.addHook('preHandler', async (req, res) => {
+            this.app.addHook('onRequest', async (req, res) => {
                 res.extraLogInfo = {};
                 if (!req.headers.origin)
                     return;
@@ -186,7 +206,7 @@ class Server {
                 PATCH: true,
                 DELETE: true
             };
-            this.app.addHook('preHandler', async (req, res) => {
+            this.app.addHook('onRequest', async (req, res) => {
                 if (!authenticatedMethods[req.method])
                     return;
                 try {
@@ -230,14 +250,14 @@ class Server {
                     for (const v of err.validation ?? []) {
                         if (v.keyword === 'errorMessage') {
                             for (const ov of v.params.errors) {
-                                if (['type', 'additionalProperties'].includes(ov.keyword))
+                                if (['type', 'additionalProperties', 'minProperties'].includes(ov.keyword))
                                     developerErrors.push({ ...ov, message: v.message });
                                 else
                                     userErrors.push({ ...ov, message: v.message });
                             }
                         }
                         else {
-                            if (['type', 'additionalProperties'].includes(v.keyword))
+                            if (['type', 'additionalProperties', 'minProperties'].includes(v.keyword))
                                 developerErrors.push(v);
                             else
                                 userErrors.push(v);
@@ -340,7 +360,31 @@ this is log into this application and use dev tools to pull your token from the
             // Apply the security globally to all operations
             openapi.security = [{ unifiedAuth: [] }];
         }
-        await this.app.register(swagger_1.default, { openapi });
+        function findRefs(obj, id) {
+            if (obj == null)
+                return undefined;
+            if (obj.$id?.length)
+                id = obj.$id;
+            if (obj.$ref === '#' && id?.length) {
+                obj.type = 'string';
+                obj.enum = [id];
+                delete obj.$ref;
+            }
+            else {
+                for (const val of Object.values(obj)) {
+                    if (typeof val === 'object' && !(val instanceof Date))
+                        findRefs(val, id);
+                }
+            }
+            return obj;
+        }
+        await this.app.register(swagger_1.default, {
+            openapi,
+            transform({ schema, url, route, swaggerObject, openapiObject }) {
+                const newSchema = findRefs((0, txstate_utils_1.clone)(schema));
+                return { schema: newSchema, url, route, swaggerObject, openapiObject };
+            }
+        });
         await this.app.register(swagger_ui_1.default, { ...opts?.ui, routePrefix: opts?.path ?? opts?.ui?.routePrefix ?? '/docs' });
     }
     async close(softSeconds) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify-txstate",
-  "version": "3.2.12",
+  "version": "3.2.14",
   "description": "A small wrapper for fastify providing a set of common conventions & utility functions we use.",
   "exports": {
     ".": {
@@ -18,7 +18,7 @@
     "testserver": "node -r ts-node/register --no-warnings testserver/index.ts"
   },
   "dependencies": {
-    "@elastic/elasticsearch": "^8.12.2",
+    "@elastic/elasticsearch": "^8.13.0",
     "@fastify/swagger": "^8.14.0",
     "@fastify/swagger-ui": "^3.0.0",
     "@fastify/type-provider-json-schema-to-ts": "^3.0.0",