@sleekify/sleekify-fastify 1.0.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,127 @@
+# <img src="resources/sleekify.png" height="27"> Sleekify Fastify Integration
+
+This project's goal is to simplify the development of REST web services in NodeJS by bringing the best of the Java API for RESTful Web Services (JAX-RS) to TypeScript.
+This is possible since TypeScript decorators may be used in a manner similar to Java annotations.
+This project allows you to apply decorators to your resource classes to identify your REST resources and associate them with OpenAPI definitions.
+This allows you to maintain your API documentation alongside your code using typed definitions.
+If you ever had to maintain a large OpenAPI specification by hand, this should grab your attention.
+Your API documentation will both match the OpenAPI specification's schema and be generated from your code.
+
+## Getting Started
+
+1. First, install Sleekify and the Fastify integration
+   ```bash
+   npm install @sleekify/sleekify
+   npm install @sleekify/sleekify-fastify
+   ```
+
+2. Create REST resources using the provided decorators
+   <br/><sub>_src/v1/users.ts_</sub>
+   ```TypeScript
+   @Path({
+     path: '/v1/users/{id}',
+     parameters: [
+       {
+         $ref: '#/components/parameters/id'
+       }
+     ]
+   })
+   @Schema({
+     $ref: '#/components/schemas/user'
+   })
+   export class UsersIdResource {
+     @GET()
+     async getOne () {
+       // TODO: your read user code here
+     }
+   
+     @PUT()
+     async updateOne () {
+       // TODO: your update user code here
+     }
+   
+     @DELETE()
+     async deleteOne () {
+       // TODO: your delete user code here
+     }
+   }
+   ```
+
+2. Create your base OpenAPI specification
+   <br/><sub>_src/openapi.ts_</sub>
+   ```TypeScript
+   import { OpenAPIObject } from '@sleekify/sleekify';
+   
+   export const specification: OpenAPIObject = {
+     openapi: '3.1.1',
+     info: {
+       title: 'Test API',
+       version: '1.0.0'
+     },
+     components: {
+       parameters: {
+         id: {
+           description: 'The identifier of the resource',
+           name: 'id',
+           in: 'path',
+           required: true,
+           schema: {
+           $ref: '#/components/schemas/id'
+         }
+       },
+       schemas: {
+         id: {
+           description: 'The id path parameter schema',
+           type: ['integer']
+         },
+         user: {
+           type: ['object'],
+           properties: {
+             id: {
+               type: ['number']
+             },
+             name: {
+               type: ['string']
+             }
+           }
+         }
+       }
+     }
+   };
+   ```
+
+4. Register your OpenAPI specification and resources with Fastify
+   <br/><sub>_src/index.ts_</sub>
+   ```TypeScript
+   import Fastify from 'fastify';
+   import { Annotation, Path } from '@sleekify/sleekify';
+   import { Sleekify } from '@sleekify/sleekify-fastify';
+   import { specification } from './openapi';
+   
+   const fastify = Fastify({
+     logger: true
+   });
+   
+   async function run () {
+     // 1. Find all of your resource classes
+     const classList = await Annotation.getClassesAnnotatedWith('./v1', Path);
+     // 2. Create a Sleekify instance
+     const sleekify = new Sleekify(specification, classList);
+   
+     // 3. Register Sleekify with Fastify
+     await fastify.register(sleekify.getPlugin());
+   
+     fastify.listen({ port: 3000 }, function (error) {
+       if (error != null) {
+         fastify.log.error(error);
+         process.exit(1);
+       }
+     });
+   }
+   
+   void run();
+   ```
+
+## API Documentation
+
+For more information on the provided decorators, OpenAPI types, and web application errors see the [Sleekify API Reference](https://github.com/sleekify/sleekify).

package/dist/src/index.d.ts

@@ -0,0 +1,43 @@
+import { type FastifyReply, type FastifyRequest } from 'fastify';
+import { type OpenAPIObject } from '@sleekify/sleekify';
+/**
+ * This class provides the Sleekify integration for Fastify.
+ */
+export declare class Sleekify {
+    private readonly classArray;
+    private readonly specification;
+    private serviceHandlers?;
+    private plugin?;
+    /**
+     * Creates a new Sleekify instance.
+     *
+     * @param specification The OpenAPI base specification
+     * @param classArray The resource classes to include in the OpenAPI specification
+     */
+    constructor(specification: OpenAPIObject, classArray: any[]);
+    /**
+     * Get a Fastify plugin which you can register.
+     */
+    getPlugin(): (fastify: any, options: any) => Promise<any>;
+    /**
+     * Get the OpenAPI specification which may be passed to Fastify OpenAPI glue.
+     * @param options The options
+     * @param options.pretty Sort the specification path's etc.
+     */
+    getSpecification(options?: {
+        pretty?: boolean;
+    }): OpenAPIObject;
+    /**
+     * Get the service handlers which may be passed to Fastify OpenAPI glue.
+     */
+    getServiceHandlers(): Record<string, (request: FastifyRequest, reply: FastifyReply) => Promise<any>>;
+    private initialize;
+    private addComponents;
+    private addPath;
+    private addRequestBody;
+    private addResponses;
+    private addSchemas;
+    private addServiceHandlers;
+    private getSuccessStatusCodes;
+    private sortObject;
+}

package/dist/src/index.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sleekify = void 0;
+const fastify_plugin_1 = require("fastify-plugin");
+const sleekify_1 = require("@sleekify/sleekify");
+const tsimportlib_1 = require("tsimportlib");
+const lodash_1 = __importDefault(require("lodash"));
+const methodMapArray = [
+    {
+        decorator: sleekify_1.DELETE,
+        key: 'delete'
+    },
+    {
+        decorator: sleekify_1.GET,
+        key: 'get'
+    },
+    {
+        decorator: sleekify_1.HEAD,
+        key: 'head'
+    },
+    {
+        decorator: sleekify_1.OPTIONS,
+        key: 'options'
+    },
+    {
+        decorator: sleekify_1.PATCH,
+        key: 'patch'
+    },
+    {
+        decorator: sleekify_1.POST,
+        key: 'post'
+    },
+    {
+        decorator: sleekify_1.PUT,
+        key: 'put'
+    },
+    {
+        decorator: sleekify_1.TRACE,
+        key: 'trace'
+    }
+];
+/**
+ * This class provides the Sleekify integration for Fastify.
+ */
+class Sleekify {
+    classArray;
+    specification;
+    serviceHandlers;
+    plugin;
+    /**
+     * Creates a new Sleekify instance.
+     *
+     * @param specification The OpenAPI base specification
+     * @param classArray The resource classes to include in the OpenAPI specification
+     */
+    constructor(specification, classArray) {
+        this.classArray = classArray;
+        this.specification = JSON.parse(JSON.stringify(specification));
+    }
+    /**
+     * Get a Fastify plugin which you can register.
+     */
+    getPlugin() {
+        this.initialize();
+        if (this.plugin !== undefined) {
+            return this.plugin;
+        }
+        const plugin = async (fastify, options) => {
+            /* This is an ES module so we must import it dynamically */
+            const { fastifyOpenapiGlue } = (await (0, tsimportlib_1.dynamicImport)('fastify-openapi-glue', module));
+            await fastifyOpenapiGlue(fastify, {
+                ...options,
+                specification: this.getSpecification(),
+                serviceHandlers: this.serviceHandlers
+            });
+        };
+        this.plugin = (0, fastify_plugin_1.fastifyPlugin)(plugin, {
+            fastify: '>=4.0.0',
+            name: '@sleekify/sleekify-fastify'
+        });
+        return this.plugin;
+    }
+    /**
+     * Get the OpenAPI specification which may be passed to Fastify OpenAPI glue.
+     * @param options The options
+     * @param options.pretty Sort the specification path's etc.
+     */
+    getSpecification(options) {
+        this.initialize();
+        const result = JSON.parse(JSON.stringify(this.specification));
+        if (options?.pretty === true) {
+            this.sortObject(result, 'paths');
+            this.sortObject(result, 'webhooks');
+            this.sortObject(result, 'components');
+            const components = [
+                'callbacks',
+                'examples',
+                'links',
+                'parameters',
+                'pathItems',
+                'requestBodies',
+                'responses',
+                'schemas',
+                'securitySchemes'
+            ];
+            for (const key of components) {
+                this.sortObject(result, `components.${key}`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Get the service handlers which may be passed to Fastify OpenAPI glue.
+     */
+    getServiceHandlers() {
+        this.initialize();
+        return this.serviceHandlers;
+    }
+    initialize() {
+        if (this.serviceHandlers !== undefined) {
+            /* already initialized */
+            return;
+        }
+        this.serviceHandlers = {};
+        for (const clazz of this.classArray) {
+            const Clazz = clazz;
+            const classInstance = new Clazz();
+            const componentsObject = sleekify_1.Annotation.get(clazz, undefined, sleekify_1.Components);
+            const pathItemObject = sleekify_1.Annotation.get(clazz, undefined, sleekify_1.Path);
+            if (componentsObject !== undefined) {
+                this.addComponents(clazz, componentsObject);
+            }
+            if (pathItemObject !== undefined) {
+                this.addServiceHandlers(clazz, classInstance, pathItemObject);
+            }
+        }
+        // TODO - sort specification?
+    }
+    addComponents(clazz, componentsObject) {
+        if (this.specification.components === undefined) {
+            this.specification.components = {};
+        }
+        const propertyNameArray = [
+            'schemas',
+            'responses',
+            'parameters',
+            'examples',
+            'requestBodies',
+            'headers',
+            'securitySchemes',
+            'links',
+            'callbacks',
+            'pathItems'
+        ];
+        for (const propertyName of propertyNameArray) {
+            if (componentsObject[propertyName] === undefined) {
+                continue;
+            }
+            let componentsSection = this.specification.components[propertyName];
+            if (componentsSection === undefined) {
+                componentsSection = this.specification.components[propertyName] = {};
+            }
+            Object.assign(componentsSection, componentsObject[propertyName]);
+        }
+    }
+    addPath(path, pathItemObject, operationMap) {
+        if (lodash_1.default.isEmpty(operationMap)) {
+            return;
+        }
+        if (this.specification.paths === undefined) {
+            this.specification.paths = {};
+        }
+        if (this.specification.paths[path] === undefined) {
+            this.specification.paths[path] = {
+                ...lodash_1.default.omit(pathItemObject, 'path'),
+                ...operationMap
+            };
+        }
+    }
+    addRequestBody(operationObject, resolvedConsumes, resolvedSchema) {
+        if (operationObject.requestBody === undefined) {
+            operationObject.requestBody = {};
+        }
+        const referenceObject = operationObject.requestBody;
+        const requestBody = operationObject.requestBody;
+        if (referenceObject.$ref === undefined && requestBody.content === undefined) {
+            operationObject.requestBody = {
+                content: resolvedConsumes.reduce((content, mediaType) => {
+                    content[mediaType] = {
+                        schema: resolvedSchema
+                    };
+                    return content;
+                }, {})
+            };
+        }
+    }
+    addResponses(operationObject, resolvedProduces, resolvedSchema, resolvedStatusCodes) {
+        if (resolvedStatusCodes.length === 0) {
+            return;
+        }
+        if (operationObject.responses === undefined) {
+            operationObject.responses = {};
+        }
+        for (const resolvedStatusCode of resolvedStatusCodes) {
+            if (operationObject.responses[resolvedStatusCode] === undefined) {
+                /* add a new response object */
+                operationObject.responses[resolvedStatusCode] = {
+                    description: 'Successful response',
+                    content: resolvedProduces.reduce((content, mediaType) => {
+                        content[mediaType] = {
+                            schema: resolvedSchema
+                        };
+                        return content;
+                    }, {})
+                };
+            }
+            else {
+                const referenceOrResponse = operationObject.responses[resolvedStatusCode];
+                if (referenceOrResponse.$ref === undefined && referenceOrResponse.content === undefined) {
+                    const responseObject = operationObject.responses[resolvedStatusCode];
+                    /* add content to an existing response object */
+                    responseObject.content = resolvedProduces.reduce((content, mediaType) => {
+                        content[mediaType] = {
+                            schema: resolvedSchema
+                        };
+                        return content;
+                    }, {});
+                }
+            }
+        }
+    }
+    addSchemas(clazz, propertyName, operationObject, methodKey) {
+        const classConsumes = sleekify_1.Annotation.get(clazz, undefined, sleekify_1.Consumes);
+        const classProduces = sleekify_1.Annotation.get(clazz, undefined, sleekify_1.Produces);
+        const classSchema = sleekify_1.Annotation.get(clazz, undefined, sleekify_1.Schema);
+        const methodConsumes = sleekify_1.Annotation.get(clazz, propertyName, sleekify_1.Consumes);
+        const methodProduces = sleekify_1.Annotation.get(clazz, propertyName, sleekify_1.Produces);
+        const methodSchema = sleekify_1.Annotation.get(clazz, propertyName, sleekify_1.Schema);
+        const resolvedConsumes = methodConsumes ?? classConsumes ?? ['application/json'];
+        const resolvedProduces = methodProduces ?? classProduces ?? ['application/json'];
+        const resolvedSchema = methodSchema ?? classSchema;
+        if (resolvedSchema === undefined) {
+            return;
+        }
+        if (['patch', 'post', 'put'].includes(methodKey)) {
+            this.addRequestBody(operationObject, resolvedConsumes, resolvedSchema);
+        }
+        const resolvedStatusCodes = this.getSuccessStatusCodes(operationObject);
+        this.addResponses(operationObject, resolvedProduces, resolvedSchema, resolvedStatusCodes);
+    }
+    addServiceHandlers(clazz, classInstance, pathItemObject) {
+        const path = pathItemObject.path;
+        const operationMap = {};
+        for (const propertyName of Object.getOwnPropertyNames(Object.getPrototypeOf(classInstance))) {
+            const propertyValue = classInstance[propertyName];
+            if (['constructor', 'function'].includes(propertyName) || !lodash_1.default.isFunction(propertyValue)) {
+                continue;
+            }
+            for (const methodMap of methodMapArray) {
+                const decorator = methodMap.decorator;
+                if (!sleekify_1.Annotation.exists(clazz, propertyName, decorator)) {
+                    continue;
+                }
+                const methodKey = methodMap.key;
+                const operationObject = lodash_1.default.cloneDeep(sleekify_1.Annotation.get(clazz, propertyName, decorator) ?? {});
+                operationMap[methodKey] = operationObject;
+                if (operationObject.operationId === undefined) {
+                    operationObject.operationId = lodash_1.default.camelCase(`${methodKey}${path}`.replace(/\//g, '_').replace(/{/g, '').replace(/}/g, ''));
+                }
+                this.addSchemas(clazz, propertyName, operationObject, methodKey);
+                this.serviceHandlers[operationObject.operationId] = async (request, reply) => {
+                    const result = classInstance[propertyName](request, reply);
+                    return result instanceof Promise ? await result : result;
+                };
+            }
+        }
+        this.addPath(path, pathItemObject, operationMap);
+    }
+    getSuccessStatusCodes(operationObject) {
+        const successStatusCodes = [];
+        if (operationObject.responses !== undefined) {
+            for (const responseKey in operationObject.responses) {
+                const statusCode = Number.parseInt(responseKey);
+                if (!Number.isNaN(statusCode) && statusCode >= 200 && statusCode < 300) {
+                    successStatusCodes.push(statusCode);
+                }
+            }
+        }
+        const resolvedStatusCodes = [];
+        if (successStatusCodes.length > 0) {
+            for (const statusCode of [200, 201]) {
+                if (successStatusCodes.includes(statusCode)) {
+                    resolvedStatusCodes.push(statusCode);
+                }
+            }
+        }
+        else {
+            resolvedStatusCodes.push(200);
+        }
+        return resolvedStatusCodes;
+    }
+    sortObject(root, path) {
+        const object = lodash_1.default.get(root, path);
+        if (object === undefined) {
+            return;
+        }
+        const result = {};
+        const sortedKeys = Object.keys(object).sort();
+        for (const key of sortedKeys) {
+            result[key] = object[key];
+        }
+        lodash_1.default.set(root, path, result);
+    }
+}
+exports.Sleekify = Sleekify;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@sleekify/sleekify-fastify",
+  "version": "1.0.0",
+  "description": "A TypeScript decorator driven approach for developing Fastify web applications.",
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint --ext .ts .",
+    "test": "node --experimental-vm-modules ./node_modules/.bin/jest",
+    "validate": "npm run build && npm run lint -- --fix && npm test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sleekify/sleekify-fastify.git"
+  },
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "files": [
+    "/dist/src"
+  ],
+  "author": "Jesse Walseth",
+  "license": "Apache License 2.0",
+  "bugs": {
+    "url": "https://github.com/sleekify/sleekify-fastify/issues"
+  },
+  "homepage": "https://github.com/sleekify/sleekify-fastify#readme",
+  "devDependencies": {
+    "@tsconfig/node18": "^18.2.0",
+    "@types/jest": "^29.5.3",
+    "@types/lodash": "^4.14.196",
+    "@types/uuid": "^9.0.2",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "@typescript-eslint/parser": "^6.4.0",
+    "axios": "^1.5.0",
+    "eslint": "^8.47.0",
+    "eslint-config-standard-with-typescript": "^38.0.0",
+    "eslint-plugin-import": "^2.28.1",
+    "eslint-plugin-n": "^16.0.1",
+    "eslint-plugin-promise": "^6.1.1",
+    "jest": "^29.6.2",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.1.6"
+  },
+  "dependencies": {
+    "@sleekify/sleekify": "^1.0.0",
+    "@types/node": "^20.4.5",
+    "fastify": "^5.0.0",
+    "fastify-openapi-glue": "^4.7.1",
+    "fastify-plugin": "^5.0.1",
+    "lodash": "^4.17.21",
+    "openapi-types": "^12.1.3",
+    "tsimportlib": "^0.0.5",
+    "uuid": "^9.0.0"
+  }
+}