@platformatic/sql-json-schema-mapper 0.19.0 → 0.19.2

package/index.js

@@ -1,5 +1,8 @@
 'use strict'
 
+const CodeBlockWriter = require('code-block-writer').default
+const { property } = require('safe-identifier')
+
 function mapSQLTypeToOpenAPIType (sqlType) {
   // TODO support more types
   /* istanbul ignore next */
@@ -91,7 +94,7 @@ function mapSQLEntityToJSONSchema (entity, ignore = {}) {
       properties[field.camelcase].enum = field.enum
     }
   }
-  return {
+  const res = {
     $id: entity.name,
     title: entity.name,
     description: `A ${entity.name}`,
@@ -99,6 +102,104 @@ function mapSQLEntityToJSONSchema (entity, ignore = {}) {
     properties,
     required
   }
+
+  return res
+}
+
+function mapOpenAPItoTypes (obj, opts = {}) {
+  let { writer, addedProps } = opts
+  addedProps ??= new Set()
+  writer ??= new CodeBlockWriter()
+  const { title, description, properties, required, additionalProperties } = obj
+  writer.write('/**').newLine()
+  writer.write(` * ${title}`).newLine()
+  writer.write(` * ${description}`).newLine()
+  writer.write(' */').newLine()
+  writer.write(`declare interface ${title}`).block(() => {
+    renderProperties(writer, addedProps, properties, additionalProperties, required)
+  })
+  return writer.toString()
+}
+
+function renderProperties (writer, addedProps, properties = {}, additionalProperties, required = []) {
+  for (const name of Object.keys(properties)) {
+    const { type, nullable, items } = properties[name]
+    addedProps.add(name)
+    if (required.indexOf(name) !== -1) {
+      writer.write(property(null, name))
+    } else {
+      writer.write(property(null, name))
+      writer.write('?')
+    }
+
+    let types
+    if (Array.isArray(type)) {
+      types = type
+    } else {
+      types = [type]
+    }
+
+    if (nullable && types.indexOf('null') === -1) {
+      types.push('null')
+    }
+
+    let first = true
+    writer.write(': ')
+    for (const type of types) {
+      if (!first) {
+        writer.write(' | ')
+      }
+      first = false
+      if (type === 'null') {
+        writer.write('null')
+      } else if (type === 'array') {
+        switch (items.type) {
+          case 'object':
+            writer.inlineBlock(() => {
+              const current = items
+              renderProperties(writer, addedProps, current.properties, current.additionalProperties, current.required)
+            })
+            writer.write('[]')
+            break
+            // TODO support arrays in arrays
+          default:
+            writer.write(`${JSONSchemaToTsType(items.type)}[]`)
+        }
+      } else if (type === 'object') {
+        writer.inlineBlock(() => {
+          const current = properties[name]
+          renderProperties(writer, addedProps, current.properties, current.additionalProperties, current.required)
+        })
+      } else {
+        writer.write(JSONSchemaToTsType(type))
+      }
+    }
+
+    writer.write(';')
+    writer.newLine()
+  }
+
+  if (additionalProperties) {
+    writer.write('[name: string]: any;')
+  }
+}
+
+function JSONSchemaToTsType (type) {
+  switch (type) {
+    case 'string':
+      return 'string'
+    case 'integer':
+      return 'number'
+    case 'number':
+      return 'number'
+    /* istanbul ignore next */
+    case 'boolean':
+      return 'boolean'
+    // TODO what other types should we support here?
+    /* istanbul ignore next */
+    default:
+      return 'any'
+  }
 }
 
-module.exports = { mapSQLTypeToOpenAPIType, mapSQLEntityToJSONSchema }
+module.exports = { mapSQLTypeToOpenAPIType, mapSQLEntityToJSONSchema, mapOpenAPItoTypes }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/sql-json-schema-mapper",
-  "version": "0.19.0",
+  "version": "0.19.2",
   "description": "Map SQL entity to JSON schema",
   "main": "index.js",
   "repository": {
@@ -18,7 +18,12 @@
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.3.4",
-    "@platformatic/sql-mapper": "0.19.0"
+    "@platformatic/sql-mapper": "0.19.2"
+  },
+  "dependencies": {
+    "code-block-writer": "^12.0.0",
+    "dtsgenerator": "^3.18.0",
+    "safe-identifier": "^0.4.2"
   },
   "scripts": {
     "lint": "standard | snazzy",

package/test/types.test.js

@@ -0,0 +1,189 @@
+'use strict'
+
+const { test } = require('tap')
+const dtsgenerator = require('dtsgenerator')
+const { mapOpenAPItoTypes } = require('..')
+
+let structuredClone = globalThis.structuredClone
+if (structuredClone === undefined) {
+  structuredClone = (obj) => JSON.parse(JSON.stringify(obj))
+}
+
+function referenceTest (name, obj, opts = {}) {
+  const { only } = opts
+  test(name, { only }, async t => {
+    const reference = await dtsgenerator.default({ contents: [dtsgenerator.parseSchema(structuredClone(obj))] })
+    const cloned = structuredClone(obj)
+    const ours = mapOpenAPItoTypes(cloned)
+    t.not(cloned, obj)
+    t.same(cloned, obj)
+    t.same(ours.trim(), reference.trim())
+  })
+}
+
+referenceTest('p1', {
+  id: 'Page',
+  title: 'Page',
+  description: 'A Page',
+  type: 'object',
+  properties: {
+    id: {
+      type: 'integer'
+    },
+    title: {
+      type: 'string'
+    },
+    metadata: {
+      type: 'object',
+      additionalProperties: true,
+      nullable: true
+    },
+    section: {
+      type: 'number',
+      nullable: true
+    },
+    description: {
+      type: 'string',
+      nullable: true
+    }
+  },
+  required: [
+    'title'
+  ]
+})
+
+referenceTest('p2', {
+  id: 'Page',
+  title: 'Page',
+  description: 'A Page',
+  type: 'object',
+  properties: {
+    id: {
+      type: 'integer'
+    },
+    metadata: {
+      type: 'object',
+      additionalProperties: true,
+      nullable: true
+    },
+    section: {
+      type: 'number',
+      nullable: true
+    },
+    description: {
+      type: 'string',
+      nullable: true
+    }
+  },
+  required: []
+})
+
+referenceTest('p3', {
+  id: 'GeneratedTest',
+  title: 'GeneratedTest',
+  description: 'A GeneratedTest',
+  type: 'object',
+  properties: {
+    id: {
+      type: 'integer'
+    },
+    test: {
+      type: 'integer',
+      nullable: true
+    },
+    testStored: {
+      type: 'integer',
+      nullable: true,
+      readOnly: true
+    },
+    testVirtual: {
+      type: 'integer',
+      nullable: true,
+      readOnly: true
+    }
+  },
+  required: []
+})
+
+referenceTest('multiple types', {
+  id: 'Page',
+  title: 'Page',
+  description: 'A Page',
+  type: 'object',
+  properties: {
+    id: {
+      type: ['integer', 'string']
+    },
+    title: {
+      type: 'string'
+    },
+    metadata: {
+      type: 'object',
+      additionalProperties: true,
+      nullable: true
+    },
+    section: {
+      type: ['number', 'null']
+    },
+    description: {
+      type: 'string',
+      nullable: true
+    }
+  },
+  required: [
+    'title'
+  ]
+})
+
+referenceTest('arrays', {
+  id: 'Page',
+  title: 'Page',
+  description: 'A Page',
+  type: 'object',
+  properties: {
+    id: {
+      type: 'integer'
+    },
+    title: {
+      type: 'string'
+    },
+    tags: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }
+  },
+  required: [
+    'title'
+  ]
+})
+
+referenceTest('objects in arrays', {
+  id: 'Page',
+  title: 'Page',
+  description: 'A Page',
+  type: 'object',
+  properties: {
+    id: {
+      type: 'integer'
+    },
+    title: {
+      type: 'string'
+    },
+    tags: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          foo: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  },
+  required: [
+    'title'
+  ]
+})