I have this mongoose schema:

name: {
    type: String,
    maxlength: [256, 'Why name is too long?'] // Mongoose validator: https://mongoosejs.com/docs/validation.html#built-in-validators
},

Calling jsonSchema() give me the output with maxLength is an array.

Expected result:

maxLength: 256

I would like to see this as an option

Hi,
It looks like description will not be picked up when type is array, for example:

new mongoose.Schema(
{
name: String,
inputs: {type: [String], index: true, description: "Information operated on by rule"},
outputs: {description: "Information produced by rule", type: [String]},
}
);

Hi. Is it possible to add support for "example" field to the generated json schema which will come from the "example" field from the mongoose schema? Same as current behavior of "description" field which gets its value from the mongoose schema

I have a Mongoose schema defined with the "map" field type. Looks like-

    let richMetaDataItemSchema = mongoose.Schema({
        name: { type: String },
        language: {
            type: Map,
            of: { type: String }
        }
    });

Right now its getting transformed into a schema that looks like-

 "summary": {
      "title": "summary",
      "type": "object",
      "properties": {
        "name": {
          "type": "string"
        },
        "language": {
          "type": "map",
          "properties": {
            "$*": {
              "type": "string"
            }
          }
        }
      },

Problem is the type: "map" isnt a valid type(Or not that I can find in the docs).
I am also using the tool-https://uniforms.tools/
And that also has a problem with that field type...

Any ideas, or possible to support a valid JSONSchema construct?

Mongoose 6.0.2 renames Types.Embedded to Types.Subdocument.

I opened PR #31 to fix the issue, but a more elegant solution would be appreciated, in order to keep support for previous mongoose versions.

Proposal: using the npm list command to get a list of all installed packages, find mongoose in the output and extract version. Compare major version and if greater than 6, apply fix.

In the meanwhile, please update the package as latest version should be the one supported.

Have a great day!

Hi, i'm using your module as depends. I validate the schema by ajv, but the result is invalid.
ObjectId is not a uuid, so the format uuid make it validate failed.
Thank you.

Hi, i find a bug of the schema which has sub object with required property.
Such as, manage has a required field startAt and endAt, but i get the jsonschema with required properties name,internalName,startAt,endAt at the top level.
This will make validation failed to JSON-SCHEMA 4.
Do you have time to fix it?
Thanks.

// mongoose schema
{
    name: {
        type: String,
        required: true,
        unique: true,
    },
    description: {
        type: String,
    },
    internalName: {
        type: String,
        required: true,
        unique: true,
    },
    manage: {
       offline: { 
            type: Boolean,
            default: true,
        },
        startAt: {
            type: Date,
            required: true,
        },
        endAt: {
            type: Date,
            required: true,
        },
    },
}

// jsonschema
{
    "title": "book",
    "type": "object",
    "properties": {
        "name": {
            "type": "string"
        },
        "description": {
            "type": "string"
        },
        "internalName": {
            "type": "string"
        },
        "manage": {
            "title": "manage",
            "type": "object",
            "properties": {
                "offline": {
                    "type": "boolean",
                    "default": true
                },
                "startAt": {
                    "type": "string",
                    "format": "date-time"
                },
                "endAt": {
                    "type": "string",
                    "format": "date-time"
                }
            }
        }
    },
    "required": [
        "name",
        "internalName",
        "startAt",
        "endAt"
    ]
}

say i convert a json schema to a json object, how can i convert it back into a mongoose schema?

Hello,
so I would like to use this library but there is a main point I'm not able to resolve and maybe there is a gap in what I'm trying to achieve.
I have a NestJS application using Mongoose.
Schemas are created as follows:

`
import { PartialType } from '@nestjs/mapped-types';
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { ApiProperty } from '@nestjs/swagger';
import { Document } from 'mongoose';

export type CatDocument = Cat & Document;

@Schema()
export class Cat {

@ApiProperty()
@prop()
name: string;

@ApiProperty()
@prop()
age: number;

@ApiProperty()
@prop()
breed: string;
}

export const CatSchema = SchemaFactory.createForClass(Cat)
export class UpdateCat extends PartialType(Cat) {}
`

As you can see SchemaFactory.createForClass is invoked to obtain a schema object.
So I thought I could use it with this library but this object doesn't expose the jsonSchema().

When I create as an instance of mongoose Schema then it works.

Is this an incompatibility with NestJS SchemaFactory?

Thanks and best regards

When using the jsonSchema function on the mongoose model together with a selection, the required property is completely removed. Wouldn't it be better to check, which properties are going to be included and only delete those from the required field, that are excluded?

Example:

const BookSchema = new Schema({
 title: { type: String, required: true },
 year: { type: Number, required: true }
});
const Book = mongoose.model('Book', BookSchema);
Book.jsonSchema('title');

Response would look like:

{
  title: 'Book',
  type: 'object',
  properties: {
    title: { type: 'string'  },
  },
 required: [ 'title' ]
}

instead of

{
  title: 'Book',
  type: 'object',
  properties: {
    title: { type: 'string'  },
  }
}

Amazing job on this plugin @DScheglov
I have a schema that reference itself. Kind like a tree. Your plugin add a $ref that point to an $id but ajv does not understand.

Do you think adding a definition would be possible? If yes, and you need help, maybe you could point me in the right direction to help you out.

Hi!

Is this still maintained?

Would love to have support for TypeScript for this.

The String type needs minlength and maxlength options to be in lowercase as specified in the mongoose docs:

SchemaStringOptions.prototype.maxlength
SchemaStringOptions.prototype.minlength

PR #20

thanks for module, saved my time! one question, is it possible to exclude some fields? would be really useful if we'll be able to exclude some certain fields like ids, pw, keys etc. thanks!

Hi, didn't find any docs / example related to additionalProperties. By default, MongoDB keeps this as true.

How can make it additionalProperties: false globally, so that child objects are also validated.
Is this possible

i think it would be less error prone to have an option for passing the model to a function, without having the need for extending all the mongoose types.
e.g. i have my models in a different package than the schema-creation script. now i need to include mongoose, for schema creation and it seems, there is something off with peerDependencies or so, because the .jsonSchema function does not exist.

so instead of

mongooseModel.jsonSchema();

i would like to do:

const JsonSChema =require("mongoose-schema-jsonschema");
JsonSchema(mongooseModel);

When using mongoose 6.x.x npm install warns that mongoose-schema-jsonschema requires mongoose@^5.0.0.

Should your package.json dependencies be updated to "mongoose": "^6.0.0", or am I missing something?

The description field is not picked up for mongoose.Schema.Types.Mixed properties.

The description is actually pretty useful in these cases as these properties can get pretty complex.

Can this mess up the npm project?

$ npm i mongoose
npm WARN ERESOLVE overriding peer dependency
npm WARN While resolving: [email protected]
npm WARN Found: [email protected]
npm WARN node_modules/mongoose
npm WARN   mongoose@"^7.2.1" from the root project
npm WARN 
npm WARN Could not resolve dependency:
npm WARN peer mongoose@"^5.0.0 || ^6.0.0" from [email protected]
npm WARN node_modules/mongoose-schema-jsonschema
npm WARN   mongoose-schema-jsonschema@"^2.0.2" from the root project

up to date, audited 32 packages in 761ms

2 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

var BookSchema = new Schema({
    title: {type: String, required: true},
    year: Number,
    author: {type: String, required: true, get: function() { return 123; }}
});

returns:

{ type: 'object',
  properties: 
   { title: { type: 'string' },
     year: { type: 'number' },
     author: { type: 'string' },
     _id: { type: 'string', pattern: '^[0-9a-fA-F]{24}$' } },
  required: [ 'title', 'author' ] }

as you can see the object does not include the get function.

Hello, I've run into a problem using AutoField with my schema.

I have this object in my schema:

"discrete_components": { "type": "object", "patternProperties": { ".+": { "type": "object", "properties": { "name": { "type": "string", "maxLength": 255, "minLength": 1 }, "components": { "type": "array", "maxItems": 512, "minItems": 1, "items": { "type": "object", "required": [ "type", "range_start", "range_end" ], "properties": { "type": { "type": "string", "enum": [ "OPEN", "CLOSED", ] }, "range_start": { "type": "integer", "maximum": 255 }, "range_end": { "type": "integer", "maximum": 255 } } } } } } } }

I'm trying to use AutoField like this <AutoField name="discrete_components.someId"/> which doesn't work because AutoField looks up the field with useField, which ultimately uses the getField function from the JSONSchemaBridge class and the getField function doesn't handle patternProperties. Is this something you'd consider adding to the JSONSchemaBridge class?

I tried to extend the class but I couldn't get it working properly and this is quite a messy solution:

`
class CustomJSONSchemaBridge extends JSONSchemaBridge {

fieldInvariant = (name: string, condition: boolean) => {
invariant(condition, "Field not found in schema: "%s"", name)
}

partialNames = ["allOf", "anyOf", "oneOf"]

resolveRefIfNeeded (
partial: UnknownObject,
schema: UnknownObject,
): UnknownObject {
if (!("$ref" in partial)) {
return partial
}

const { $ref, ...partialWithoutRef } = partial
return this.resolveRefIfNeeded(
  // @ts-expect-error The `partial` and `schema` should be typed more precisely.
  Object.assign({}, partialWithoutRef, resolveRef($ref, schema)),
  schema,
)

}

getField (name: string) {
return joinName(null, name).reduce((definition, next, index, array) => {
const prevName = joinName(array.slice(0, index))
const nextName = joinName(prevName, next)
const definitionCache = (this._compiledSchema[nextName] ??= {})
definitionCache.isRequired = !!(
definition.required?.includes(next) ||
this._compiledSchema[prevName].required?.includes(next)
)

  if (next === "$" || next === "" + parseInt(next, 10)) {
    this.fieldInvariant(name, definition.type === "array")
    definition = Array.isArray(definition.items)
      ? definition.items[parseInt(next, 10)]
      : definition.items
    this.fieldInvariant(name, !!definition)
  } else if (definition.type === "object") {
    this.fieldInvariant(name, !!definition.properties)
    definition = definition.properties[joinName.unescape(next)]
    this.fieldInvariant(name, !!definition)
  } else {
    let nextFound = false
    this.partialNames.forEach(partialName => {
      definition[partialName]?.forEach((partialElement: any) => {
        if (!nextFound) {
          partialElement = this.resolveRefIfNeeded(partialElement, this.schema)
          if (next in partialElement.properties) {
            definition = partialElement.properties[next]
            nextFound = true
          }
        }
      })
    })

    // Check if 'patternProperties' is defined in the current definition
    if (definition.patternProperties) {
      for (const pattern of Object.keys(definition.patternProperties)) {
        const regex = new RegExp(pattern)
        if (regex.test(next)) {
          definition = definition.patternProperties[pattern]
          nextFound = true
          break
        }
      }
    }

    this.fieldInvariant(name, nextFound)
  }

  definition = this.resolveRefIfNeeded(definition, this.schema)

  // Naive computation of combined type, properties, and required.
  const required = definition.required ? definition.required.slice() : []
  const properties = definition.properties
    ? Object.assign({}, definition.properties)
    : {}

  this.partialNames.forEach(partialName => {
    definition[partialName]?.forEach((partial: any) => {
      partial = this.resolveRefIfNeeded(partial, this.schema)

      if (partial.required) {
        required.push(...partial.required)
      }

      Object.assign(properties, partial.properties)

      if (!definitionCache.type && partial.type) {
        definitionCache.type = partial.type
      }
    })
  })

  if (required.length > 0) {
    definitionCache.required = required
  }

  if (!isEmpty(properties)) {
    definitionCache.properties = properties
  }

  return definition
}, this.schema)

}
}
`

Or is there a better approach that I haven't thought of?

Thank you for your help!

Hi, I use this package to make development of an API using typescript, typegoose and other packages as simple as possbile.

During my developments I stumbled over a small problem with schema creation, referenced models and field exclusion. After some debugging, I identified the problem in this function:

function model_jsonSchema(fields, populate, readonly) {
  var jsonSchema = this.schema.jsonSchema(this.modelName);

  __excludedPaths(this.schema, fields).forEach(
    __delPath.bind(null, jsonSchema)
  );

  if (populate != null) {
    jsonSchema = __populate.call(this, jsonSchema, populate);
  };

  if (readonly) {
    __excludedReadonlyPaths(jsonSchema, readonly);
  }

  if (fields) __removeRequired(jsonSchema);

  return jsonSchema;
};

Do you think it is possible to switch logic for populate and excludes like this:

function model_jsonSchema(fields, populate, readonly) {
  var jsonSchema = this.schema.jsonSchema(this.modelName);

  if (populate != null) {
    jsonSchema = __populate.call(this, jsonSchema, populate);
  };

  __excludedPaths(this.schema, fields).forEach(
    __delPath.bind(null, jsonSchema)
  );

  if (readonly) {
    __excludedReadonlyPaths(jsonSchema, readonly);
  }

  if (fields) __removeRequired(jsonSchema);

  return jsonSchema;
};

With this order population happens first and after that exclusions can be done on subdocuments like this, which is an example from my code:

const pageSchema = require("../classes/models/server/Page")
        .jsonSchema(
            "-__v -author.password -author.__v -modifiedBy.password -modifiedBy.__v -category.__v",
            "author modifiedBy category",
        );

author, modifiedBy and category are referenced schemas which are populated and after that I remove some properties.

If you have any questions, feel free to ask.

Maybe this is me but I have a custom type that looks a bit like that [[Mixed]] and I do not understand how to use custom type with your package, the readme is not very clear to me

Thanks for this repo!!!!

If you have a schema, then add a field as being required programmatically, the resulting jsonschema doesn't mark the field as required.

Mongoose 5.x is released. When we could get support for it ?

I am trying to validate (with custom ajv keywords) the uniqueness and existence of specific properties of a mongoose model.
It would be a nice feature to enrich the __processOptions function in types.js with options types: exists: true|false and unique: true|false or enable a optional input of a predefined array of custom options.
Example: required('mongoose-schema-jsonschema')(mongoose, ['unique', 'exists'] )
Very nice work. Thank you.

When generating the json schema, I got the following error:

TypeError: Cannot read property 'required' of undefined
    at SchemaArray.array_jsonSchema [as jsonSchema] (/~/Documents/models/node_modules/mongoose-schema-jsonschema/lib/types.js:102:53)

It comes from this.schemaOptions.required, it looks like schemaOptions is not always defined. Especially with the following schema

const mongoose = require(`mongoose`)
const VariableSchema = require(`./VariableSchema.js`)

const ElementPathSchema = new mongoose.Schema({
  paths: {
   paths: {
      type: [[VariableSchema]],
      validate: {
        validator: function validateTemplate(arrayOfVariables) {
          return arrayOfVariables.every((variables) =>
            VariableSchema.statics.validateTemplate(variables, `elementQuery`),
          )
        },
        message: `elementPath.paths not valid`,
      },
    }
  },
})

Everything was fine with the earlier version, but suddenly my tests started failing then had a look at the version and it's 1.4.0 now.
Verified downgrading the version and my tests passed.

Throwing error "Cannot find module '../config'.

Hey,

I'd like to be able to mark fields for exclusion from the generated schema.
Some of my models have sensitive data which is not sent to end users via my API. Adding excludeFromJSONSchema: true or something similar in my model definitions would cover this use case 👍

If you can provide a hint about how you'd want this implemented I'm happy to make a pull request.

Cheers!