@audc/convert-json-schema-to-mongoose 0.3.6

package/LICENSE

@@ -0,0 +1,190 @@
+                                 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
+
+   Copyright 2014 Clever, Inc.
+
+   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/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Kristian Mandrup
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# JSON Schema to Mongoose Schema
+
+A translation library between [JSON Schema](http://json-schema.org/) and
+[Mongoose Schema](http://mongoosejs.com/docs/guide.html). Written in TypeScript.
+
+This project was created from the ashes of `json-schema-converter`. I took away
+some features and made it more single purpose and added features to the
+conversion.
+
+## Alternatives
+
+Some of the alternatives...
+
+- 2017 [generate-schema-required](https://www.npmjs.com/package/generate-schema-required)
+- 2016 [mongoosify](https://www.npmjs.com/package/mongoosify)
+- 2016 [mongoose-jsonschema](https://www.npmjs.com/package/mongoose-jsonschema)
+- 2015 [goodeggs-json-schema-converter](https://www.npmjs.com/package/goodeggs-json-schema-converter)
+- 2014 [json-schema-converter](https://www.npmjs.com/package/json-schema-converter)
+- 2014 [json-schema-to-mongoose-schema](https://www.npmjs.com/package/json-schema-to-mongoose-schema)
+
+## Installation
+
+`npm i convert-json-schema-to-mongoose -S`
+
+## Usage
+
+```typescript
+import { createMongooseSchema } from 'convert-json-schema-to-mongoose';
+
+// Or use plain javascript
+// const createMongooseSchema = require('json-schema-to-mongoose').default;
+
+// example json-schema references
+const refs =
+{
+    yep:
+    {
+        type: 'string',
+        pattern: '^\\d{3}$'
+    },
+    idSpec: {
+        type: 'object',
+        properties:
+        {
+            id:
+            {
+                $ref: 'yep'
+            }
+        }
+    }
+};
+
+// example schema to convert to mongoose schema
+const schema =
+{
+    type: 'object',
+    properties:
+    {
+        id:
+        {
+            $ref: 'yep'
+        },
+        address:
+        {
+            type: 'object',
+            properties:
+            {
+                street: {type: 'string', default: '44', pattern: '^\\d{2}$'},
+                houseColor: {type: 'string', default: '[Function=Date.now]', format: 'date-time'}
+            }
+        }
+    }
+};
+
+//Convert the schema
+const mongooseSchema = createMongooseSchema(refs, schema);
+
+//Alternative syntax, which makes it so you can convert many at one time.
+
+// var jsonSchemas = {commonRef: ..., good: ..., schema: ..., naming: ...}
+// var convert = createMongooseSchema(jsonSchemas)
+// var schemaNames = ['good', 'schema', 'naming']
+// var schemas = _.map(schemaNames, (name) => { return jsonSchemas[name] })
+// var mongooseSchemas = _.zipObject(schemaNames, schemas.reduce((mongooseSchemas, schema) => {
+//     return mongooseSchemas.concat(convert(schema))
+// }, []))
+
+console.dir(mongooseSchema, {depth: null});
+
+const Schema = new mongoose.Schema(mongooseSchema);
+
+```

package/dist/app.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/app.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const json_schema_1 = require("./lib/json-schema");
+const refs = {
+    yep: {
+        type: 'string', pattern: '^\\d{3}$'
+    }, a: {
+        type: 'array', items: {
+            type: 'object', properties: {
+                num: { type: 'number' }, str: { type: 'string' }
+            }
+        }
+    }, idSpec: {
+        type: 'object', properties: {
+            id: { $ref: 'yep' }, arr: { $ref: 'a' }
+        }
+    }
+};
+// noinspection ReservedWordAsName
+const valid = {
+    type: 'object', properties: {
+        id: { $ref: 'yep' }, arr: { $ref: 'a' }, address: {
+            type: 'object', properties: {
+                street: { type: 'integer', default: 44, minimum: 0, maximum: 50 },
+                houseColor: { type: 'string', default: '[Function=Date.now]', format: 'date-time' }
+            }
+        }
+    }
+};
+const result = (0, json_schema_1.default)(refs, valid);
+console.dir(result, { depth: null });
+//# sourceMappingURL=app.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import createMongooseSchema from './lib/json-schema';
+export { createMongooseSchema };

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMongooseSchema = void 0;
+const json_schema_1 = require("./lib/json-schema");
+exports.createMongooseSchema = json_schema_1.default;
+//# sourceMappingURL=index.js.map

package/dist/lib/json-schema.d.ts

@@ -0,0 +1,6 @@
+interface CreateMongooseSchema {
+    (refSchemas: any, jsonSchema: any): any;
+    (refSchemas: any): (jsonSchema: any) => any;
+}
+declare const _default: CreateMongooseSchema;
+export default _default;

package/dist/lib/json-schema.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const mongoose = require("mongoose");
+const typeStringToMongooseType = { 'string': String, 'boolean': Boolean, 'number': Number, 'integer': Number };
+const typeRefToMongooseType = {
+    '#/definitions/objectid': mongoose.Schema.Types.ObjectId, '#/definitions/dateOrDatetime': Date
+};
+const subSchemaTypeV3 = (parentSchema, subschema, key) => {
+    return (0 <= parentSchema.required.indexOf(key) && !_.isPlainObject(subschema)) ? {
+        type: subschema, required: true
+    } : subschema;
+};
+const subSchemaTypeV4 = (parentSchema, subschema, key) => {
+    return (0 <= parentSchema.required.indexOf(key)) ? !_.isPlainObject(subschema) ? {
+        type: subschema, required: true
+    } : subschema.hasOwnProperty('type') ? _.assign(subschema, { required: true }) : subschema : subschema;
+};
+// noinspection ReservedWordAsName
+const schemaParamsToMongoose = {
+    /**
+     * default value
+     */
+    default: (default_) => {
+        const func = (_.last(/^\[Function=(.+)\]$/.exec(default_)) || '')
+            .replace(/\\_/g, '`underscore`')
+            .replace(/_/g, ' ')
+            .replace(/`underscore`/g, '_');
+        // noinspection ReservedWordAsName,DynamicallyGeneratedCodeJS
+        return { default: eval(func) || default_ };
+    },
+    /**
+     * Pattern for value to match
+     */
+    pattern: (pattern) => ({ match: RegExp(pattern) }),
+    type: (type) => ({ type: typeStringToMongooseType[type] }),
+    minLength: (min) => ({ minlength: min }),
+    maxLength: (max) => ({ maxlength: max }),
+    minimum: (min) => ({ min: min }),
+    maximum: (max) => ({ max: max }),
+    enum: (members) => ({ enum: members })
+};
+const toMongooseParams = (acc, val, key) => {
+    let func;
+    // noinspection AssignmentResultUsedJS
+    return (func = schemaParamsToMongoose[key]) ? _.assign(acc, func(val)) : acc;
+};
+const unsupportedRefValue = (jsonSchema) => {
+    throw new Error('Unsupported $ref value: ' + jsonSchema.$ref);
+};
+const unsupportedJsonSchema = (jsonSchema) => {
+    throw new Error('Unsupported JSON schema type, `' + jsonSchema.type + '`');
+};
+const convertV = (version, refSchemas, jsonSchema) => {
+    if (!_.isPlainObject(jsonSchema)) {
+        unsupportedJsonSchema(jsonSchema);
+    }
+    let converted, result, format = jsonSchema.format, isRef = !_.isEmpty(jsonSchema.$ref), isTypeDate = ('string' === jsonSchema.type) && (('date' === format) || ('date-time' === format)), mongooseRef = typeRefToMongooseType[jsonSchema.$ref], isMongooseRef = ('undefined' != typeof (mongooseRef)), subSchema = _.isEmpty(refSchemas) ? false : refSchemas[jsonSchema.$ref], subSchemaType = (4 == version) ? subSchemaTypeV4 : subSchemaTypeV3;
+    return (result =
+        isRef ?
+            isMongooseRef ?
+                mongooseRef :
+                subSchema ?
+                    convertV(version, refSchemas, subSchema) :
+                    unsupportedRefValue(jsonSchema)
+            :
+                isTypeDate ?
+                    _.reduce(_.omit(jsonSchema, 'type', 'format'), toMongooseParams, { type: typeRefToMongooseType['#/definitions/dateOrDatetime'] })
+                    :
+                        _.has(typeStringToMongooseType, jsonSchema.type) ?
+                            _.reduce(jsonSchema, toMongooseParams, {})
+                            :
+                                (jsonSchema.type === 'object') ?
+                                    _.isEmpty(jsonSchema.properties) ?
+                                        mongoose.Schema.Types.Mixed :
+                                        (converted =
+                                            _.mapValues(jsonSchema.properties, convertV.bind(null, version, refSchemas)), jsonSchema.required ?
+                                            (_.mapValues(converted, subSchemaType.bind(null, jsonSchema))) :
+                                            converted)
+                                    :
+                                        (jsonSchema.type === 'array') ?
+                                            !_.isEmpty(jsonSchema.items) ?
+                                                [convertV(version, refSchemas, jsonSchema.items)] :
+                                                []
+                                            :
+                                                !_.has(jsonSchema, 'type') ?
+                                                    mongoose.Schema.Types.Mixed :
+                                                    unsupportedJsonSchema(jsonSchema));
+};
+const convert = (refSchemas, jsonSchema) => {
+    let version = 3;
+    switch (jsonSchema.$schema) {
+        case 'http://json-schema.org/draft-03/schema#':
+            version = 3;
+            break;
+        case 'http://json-schema.org/draft-04/schema#':
+            version = 4;
+            break;
+        // backwards compatibility
+        default:
+            version = 3;
+            break;
+    }
+    return convertV(version, refSchemas, jsonSchema);
+};
+// noinspection JSUnusedGlobalSymbols
+exports.default = _.curry(convert);
+//# sourceMappingURL=json-schema.js.map

package/dist/test/json-schema.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/json-schema.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert = require("assert");
+const _ = require("lodash");
+const mongoose = require("mongoose");
+const json_schema_1 = require("../lib/json-schema");
+describe('mongoose schema conversion:', function () {
+    describe('createMongooseSchema', function () {
+        _.each([
+            { type: 'objectttttt' }, {
+                type: 'object', properties: 'not an object'
+            }, {
+                type: 'object', properties: { email: { type: 'not a type' } }
+            }
+        ], function (invalid) {
+            it('throws when the incorrect type is given', () => {
+                assert.throws(() => {
+                    // noinspection VoidExpressionJS
+                    (0, json_schema_1.default)(void 0, invalid);
+                }, /Unsupported JSON schema/);
+                // expect(() => {
+                //   createMongooseSchema(void 0, invalid);
+                // }).toThrowError(/Unsupported JSON schema/);
+            });
+        });
+        _.each([
+            {
+                type: 'object', properties: { id: { $ref: '#/nope/nope/nope' } }
+            }
+        ], function (invalid) {
+            it('throws on unsupported ref, ' + invalid, () => {
+                assert.throws(() => {
+                    // noinspection VoidExpressionJS
+                    (0, json_schema_1.default)(void 0, invalid);
+                }, /Unsupported .ref/);
+                // expect(() => {
+                //   createMongooseSchema(void 0, invalid);
+                // }).toThrowError(/Unsupported .ref/);
+            });
+        });
+        it('should convert a valid json-schema', () => {
+            const refs = {
+                yep: { type: 'string', pattern: '^\\d{3}$' },
+                a: {
+                    type: 'array', items: { type: 'object', properties: { num: { type: 'number' }, str: { type: 'string' } } }
+                },
+                anyValue: { description: 'This can be any value.' },
+                idSpec: { type: 'object', properties: { id: { $ref: 'yep' }, arr: { $ref: 'a' } } }
+            };
+            // noinspection ReservedWordAsName
+            const valid = {
+                type: 'object', properties: {
+                    id: { $ref: 'yep' }, arr: { $ref: 'a' }, anyValue: { a: 'b' }, address: {
+                        type: 'object', properties: {
+                            street: { type: 'integer', default: 44, minimum: 0, maximum: 50 },
+                            houseColor: { type: 'string', default: '[Function=Date.now]', format: 'date-time' }
+                        }
+                    }
+                }
+            };
+            // noinspection ReservedWordAsName
+            assert.deepEqual((0, json_schema_1.default)(refs, valid), {
+                id: { type: String, match: /^\d{3}$/ },
+                arr: [{ num: { type: Number }, str: { type: String } }],
+                anyValue: mongoose.Schema.Types.Mixed,
+                address: {
+                    street: { type: Number, default: 44, min: 0, max: 50 }, houseColor: { type: Date, default: Date.now }
+                }
+            });
+            // noinspection ReservedWordAsName
+            // expect(createMongooseSchema(refs, valid)).toEqual({
+            //   id: {type: String, match: /^\d{3}$/},
+            //   arr: [{num: {type: Number}, str: {type: String}}],
+            //   anyValue: mongoose.Schema.Types.Mixed,
+            //   address: {
+            //     street: {type: Number, default: 44, min: 0, max: 50}, houseColor: {type: Date, default: Date.now}
+            //   }
+            // });
+        });
+    });
+});
+//# sourceMappingURL=json-schema.spec.js.map

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@audc/convert-json-schema-to-mongoose",
+  "version": "0.3.6",
+  "description": "A library for converting JSON schema to mongoose 5 schema",
+  "keywords": [
+    "json",
+    "schema",
+    "convert",
+    "mongo",
+    "mongoose"
+  ],
+  "homepage": "https://github.com/kristianmandrup/convert-json-schema-to-mongoose",
+  "repository": {
+    "url": "https://github.com/kristianmandrup/convert-json-schema-to-mongoose",
+    "type": "git"
+  },
+  "bugs": {
+    "url": "https://github.com/kristianmandrup/convert-json-schema-to-mongoose/issues"
+  },
+  "private": false,
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jasmine ./dist/test/*.js",
+    "start": "node dist/index.js"
+  },
+  "files": [
+    "dist/**",
+    "!*.map"
+  ],
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "mongoose": "^8.9.5"
+  },
+  "devDependencies": {
+    "@tsconfig/node20": "^20.1.4",
+    "@types/jasmine": "^5.1.5",
+    "@types/lodash": "^4.17.14",
+    "@types/node": "^22.10.7",
+    "jasmine": "^5.5.0",
+    "typescript": "^5.7.3"
+  }
+}