ac-convert-json-schema-to-mongoose 0.3.5 → 0.3.6

package/{app.js → dist/app.js}

@@ -1,31 +1,32 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var json_schema_1 = require("./lib/json-schema");
-var 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
-var 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' }
-            }
-        }
-    }
-};
-var result = json_schema_1.default(refs, valid);
-console.dir(result, { depth: null });
+"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/{index.js → dist/index.js}

@@ -1,4 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var json_schema_1 = require("./lib/json-schema");
-exports.createMongooseSchema = json_schema_1.default;
+"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/{lib → dist/lib}/json-schema.js

@@ -1,107 +1,108 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var _ = require("lodash");
-var mongoose = require("mongoose");
-var typeStringToMongooseType = { 'string': String, 'boolean': Boolean, 'number': Number, 'integer': Number };
-var typeRefToMongooseType = {
-    '#/definitions/objectid': mongoose.Schema.Types.ObjectId, '#/definitions/dateOrDatetime': Date
-};
-var subSchemaTypeV3 = function (parentSchema, subschema, key) {
-    return (0 <= parentSchema.required.indexOf(key) && !_.isPlainObject(subschema)) ? {
-        type: subschema, required: true
-    } : subschema;
-};
-var subSchemaTypeV4 = function (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
-var schemaParamsToMongoose = {
-    /**
-     * default value
-     */
-    default: function (default_) {
-        var 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: function (pattern) { return ({ match: RegExp(pattern) }); },
-    type: function (type) { return ({ type: typeStringToMongooseType[type] }); },
-    minLength: function (min) { return ({ minlength: min }); },
-    maxLength: function (max) { return ({ maxlength: max }); },
-    minimum: function (min) { return ({ min: min }); },
-    maximum: function (max) { return ({ max: max }); },
-    enum: function (members) { return ({ enum: members }); }
-};
-var toMongooseParams = function (acc, val, key) {
-    var func;
-    // noinspection AssignmentResultUsedJS
-    return (func = schemaParamsToMongoose[key]) ? _.assign(acc, func(val)) : acc;
-};
-var unsupportedRefValue = function (jsonSchema) {
-    throw new Error('Unsupported $ref value: ' + jsonSchema.$ref);
-};
-var unsupportedJsonSchema = function (jsonSchema) {
-    throw new Error('Unsupported JSON schema type, `' + jsonSchema.type + '`');
-};
-var convertV = function (version, refSchemas, jsonSchema) {
-    if (!_.isPlainObject(jsonSchema)) {
-        unsupportedJsonSchema(jsonSchema);
-    }
-    var 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));
-};
-var convert = function (refSchemas, jsonSchema) {
-    var 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);
+"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

@@ -1,37 +1,45 @@
-{
-  "name": "ac-convert-json-schema-to-mongoose",
-  "version": "0.3.5",
-  "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",
-  "dependencies": {
-    "lodash": "^4.17.21",
-    "mongoose": "^8.8.0"
-  },
-  "devDependencies": {
-    "@types/jasmine": "^5.1.4",
-    "@types/lodash": "^4.17.13",
-    "@types/node": "^22.8.7",
-    "jasmine-node": "^3.0.0"
-  },
-  "scripts": {
-    "test": "node_modules/.bin/jasmine-node ./test",
-    "start": "node index.js"
-  },
-  "main": "index"
-}
+{
+  "name": "ac-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"
+  }
+}

package/json-schema-to-mongoose.d.ts

@@ -1,7 +0,0 @@
-declare module 'json-schema-to-mongoose' {
-  // noinspection JSUnusedGlobalSymbols
-  function createMongooseSchema(refSchemas : any, jsonSchema : any) : any
-  function createMongooseSchema(refSchemas : any, jsonSchema : any) : any
-  function createMongooseSchema(refSchemas : any) : (jsonSchema : any) => any
-  function createMongooseSchema(refSchemas : any) : (jsonSchema : any) => any
-}