Merge pull request #579 from nklisch/required-properties

feat: add required properties array

Author: valentinpalkovic

README.md

@@ -49,15 +49,17 @@ generator jsonSchema {
   provider = "prisma-json-schema-generator"
   keepRelationScalarFields = "true"
   schemaId = "some-schema-id"
+  includeRequiredFields = "true"
 }
 ```
 
-The generator currently supports a single option
+The generator currently supports a few options
 
 | Key                      | Default Value | Description                                                                                                                                                                                            |
 | ------------------------ | ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
 | keepRelationScalarFields | "false"       | By default, the JSON Schema that's generated will output only objects for related model records. If set to "true", this will cause the generator to also output foreign key fields for related records |
 | schemaId                 | undefined     | Add an id to the generated schema. All references will include the schema id                                                                                                                           |
+| includeRequiredFields | "false"  |  If this flag is ```"true"``` all required scalar prisma fields that do not have a default value, will be added to the ```required``` properties field for that schema definition.
 
 **3. Run generation**
 

src/generator/model.ts

@@ -36,7 +36,22 @@ export function getJSONSchemaModel(
             type: 'object',
             properties,
         }
-
+        if (transformOptions.includeRequiredFields) {
+            const required = definitionPropsMap.reduce(
+                (filtered: string[], [name, , fieldMetaData]) => {
+                    if (
+                        fieldMetaData.required &&
+                        fieldMetaData.isScalar &&
+                        !fieldMetaData.hasDefaultValue
+                    ) {
+                        filtered.push(name)
+                    }
+                    return filtered
+                },
+                [],
+            )
+            definition.required = required
+        }
         return [model.name, definition]
     }
 }

src/generator/properties.ts

@@ -183,6 +183,8 @@ export function getJSONSchemaProperty(
     return (field: DMMF.Field): PropertyMap => {
         const propertyMetaData: PropertyMetaData = {
             required: field.isRequired,
+            hasDefaultValue: field.hasDefaultValue,
+            isScalar: isScalarType(field) || isEnumType(field),
         }
 
         const property = isSingleReference(field)

src/generator/types.ts

@@ -3,6 +3,8 @@ import { JSONSchema7Definition } from 'json-schema'
 
 export interface PropertyMetaData {
     required: boolean
+    hasDefaultValue: boolean
+    isScalar: boolean
 }
 
 export interface ModelMetaData {
@@ -15,4 +17,5 @@ export type PropertyMap = [...DefinitionMap, PropertyMetaData]
 export interface TransformOptions {
     keepRelationScalarFields?: 'true' | 'false'
     schemaId?: string
+    includeRequiredFields?: 'true' | 'false'
 }

src/tests/generator.test.ts

@@ -261,6 +261,105 @@ describe('JSON Schema Generator', () => {
             })
         })
 
+        it('adds required field if requested', async () => {
+            const dmmf = await getDMMF({ datamodel: datamodelPostGresQL })
+            expect(
+                transformDMMF(dmmf, { includeRequiredFields: 'true' }),
+            ).toEqual({
+                $schema: 'http://json-schema.org/draft-07/schema#',
+                definitions: {
+                    Post: {
+                        properties: {
+                            id: { type: 'integer' },
+                            user: {
+                                anyOf: [
+                                    { $ref: '#/definitions/User' },
+                                    { type: 'null' },
+                                ],
+                            },
+                        },
+                        type: 'object',
+                        required: [],
+                    },
+                    User: {
+                        properties: {
+                            biography: {
+                                type: [
+                                    'number',
+                                    'string',
+                                    'boolean',
+                                    'object',
+                                    'array',
+                                    'null',
+                                ],
+                            },
+                            createdAt: { format: 'date-time', type: 'string' },
+                            email: {
+                                description:
+                                    'Triple Slash Comment: Will show up in JSON schema [EMAIL]',
+                                type: 'string',
+                            },
+                            number: {
+                                type: 'integer',
+                                default: '34534535435353',
+                            },
+                            bytes: {
+                                description:
+                                    'Triple Slash Inline Comment: Will show up in JSON schema [BYTES]',
+                                type: 'string',
+                            },
+                            favouriteDecimal: {
+                                default: 22.222222,
+                                type: 'number',
+                            },
+                            id: { type: 'integer' },
+                            is18: { default: false, type: ['boolean', 'null'] },
+                            keywords: {
+                                items: { type: 'string' },
+                                type: 'array',
+                            },
+                            name: {
+                                default: 'Bela B',
+                                type: ['string', 'null'],
+                            },
+                            posts: {
+                                items: { $ref: '#/definitions/Post' },
+                                type: 'array',
+                            },
+                            predecessor: {
+                                anyOf: [
+                                    { $ref: '#/definitions/User' },
+                                    { type: 'null' },
+                                ],
+                            },
+                            role: {
+                                default: 'USER',
+                                enum: ['USER', 'ADMIN'],
+                                type: 'string',
+                            },
+                            successor: {
+                                anyOf: [
+                                    { $ref: '#/definitions/User' },
+                                    { type: 'null' },
+                                ],
+                            },
+                            weight: {
+                                default: 333.33,
+                                type: ['number', 'null'],
+                            },
+                        },
+                        type: 'object',
+                        required: ['email', 'bytes', 'keywords', 'biography'],
+                    },
+                },
+                properties: {
+                    post: { $ref: '#/definitions/Post' },
+                    user: { $ref: '#/definitions/User' },
+                },
+                type: 'object',
+            })
+        })
+
         it('adds schema id', async () => {
             const dmmf = await getDMMF({ datamodel: datamodelPostGresQL })
             expect(