fix(jex): ignore additionalProperties false + intersection of union should extend union

jex/.vscode/launch.json

@@ -4,6 +4,18 @@
   // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
   "version": "0.2.0",
   "configurations": [
+    {
+      "name": "Debug TS File",
+      "type": "node",
+      "request": "launch",
+      "runtimeExecutable": "node",
+      "runtimeArgs": ["--nolazy", "-r", "ts-node/register/transpile-only"],
+      "args": ["${file}"],
+      "cwd": "${workspaceRoot}",
+      "console": "integratedTerminal",
+      "skipFiles": ["<node_internals>/**", "node_modules/**"],
+      "envFile": "${workspaceFolder}/.env"
+    },
     {
       "type": "node",
       "request": "launch",

jex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bpinternal/jex",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "JSON-Extends; JSON Schema type checking library",
   "main": "dist/index.cjs",
   "types": "dist/src/index.d.ts",

jex/src/jex-extends.test.ts

@@ -233,3 +233,11 @@ test('jex-extends should be true when child implements all parent intersection',
   const parent = $.intersection([foo, bar])
   expectJex(child).toExtend(parent)
 })
+
+test('jex-extends should allow intersection of union to extend union', () => {
+  const typeA = $.string()
+  const typeB = $.union([$.literal('a'), $.literal('b')])
+  const child = $.intersection([typeA, typeB])
+  const parent = typeB
+  expectJex(child).toExtend(parent)
+})

jex/src/jex-extends.ts

@@ -66,31 +66,31 @@ const _jexExtends = (path: PropertyPath, typeA: jexir.JexIR, typeB: jexir.JexIR)
     return { result: false, reasons: [{ path, typeA, typeB }] }
   }
 
-  if (typeA.type === 'union') {
-    const extensions = typeA.anyOf.map((c) => _jexExtends(path, c, typeB))
+  if (typeB.type === 'intersection') {
+    const extensions = typeB.allOf.map((c) => _jexExtends(path, typeA, c))
     const [_, failures] = _splitSuccessFailure(extensions)
-    if (failures.length === 0) return { result: true } // A union all extends B
+    if (failures.length === 0) return { result: true } // A extends all of the B intersection
     return { result: false, reasons: failures.flatMap((f) => f.reasons) }
   }
 
-  if (typeB.type === 'union') {
-    const extensions = typeB.anyOf.map((c) => _jexExtends(path, typeA, c))
+  if (typeA.type === 'intersection') {
+    const extensions = typeA.allOf.map((c) => _jexExtends(path, c, typeB))
     const [success, failures] = _splitSuccessFailure(extensions)
-    if (success.length > 0) return { result: true } // A extends at least one of the B union
+    if (success.length > 0) return { result: true } // At least one of A extends B
     return { result: false, reasons: failures.flatMap((f) => f.reasons) }
   }
 
-  if (typeB.type === 'intersection') {
-    const extensions = typeB.allOf.map((c) => _jexExtends(path, typeA, c))
+  if (typeA.type === 'union') {
+    const extensions = typeA.anyOf.map((c) => _jexExtends(path, c, typeB))
     const [_, failures] = _splitSuccessFailure(extensions)
-    if (failures.length === 0) return { result: true } // A extends all of the B intersection
+    if (failures.length === 0) return { result: true } // A union all extends B
     return { result: false, reasons: failures.flatMap((f) => f.reasons) }
   }
 
-  if (typeA.type === 'intersection') {
-    const extensions = typeA.allOf.map((c) => _jexExtends(path, c, typeB))
+  if (typeB.type === 'union') {
+    const extensions = typeB.anyOf.map((c) => _jexExtends(path, typeA, c))
     const [success, failures] = _splitSuccessFailure(extensions)
-    if (success.length > 0) return { result: true } // At least one of A extends B
+    if (success.length > 0) return { result: true } // A extends at least one of the B union
     return { result: false, reasons: failures.flatMap((f) => f.reasons) }
   }
 

jex/src/jexir/from-json-schema.test.ts

@@ -40,7 +40,6 @@ test('JexIR should should throw an error when the JSON schema is unsuported', ()
   ]
   expectJsonSchema(foo({ not: { type: 'number' } })).toFailAt(path)
   expectJsonSchema(foo({ oneOf: [] })).toFailAt(path)
-  expectJsonSchema(foo({ additionalItems: {} })).toFailAt(path)
   expectJsonSchema(foo({ patternProperties: {} })).toFailAt(path)
   expectJsonSchema(foo({ propertyNames: {} })).toFailAt(path)
   expectJsonSchema(foo({ if: {} })).toFailAt(path)
@@ -200,6 +199,25 @@ test('JexIR should model a object type with both properties and additionalProper
   })
 })
 
+test('JexIR should not treat additionalProperties false as an intersection with a record', () => {
+  // { name: string; age: number } ⊈ { name: string; age: number } & Record<string, never>
+  expectJsonSchema({
+    type: 'object',
+    properties: {
+      name: $.string(),
+      age: $.number()
+    },
+    required: ['name', 'age'],
+    additionalProperties: false
+  }).toEqualJex({
+    type: 'object',
+    properties: {
+      name: { type: 'string' },
+      age: { type: 'number' }
+    }
+  })
+})
+
 test('JexIR should model unknown type', () => {
   expectJsonSchema($.unknown()).toEqualJex({ type: 'unknown' })
 })
@@ -211,8 +229,8 @@ test('JexIR should model tuple types', () => {
   })
 })
 
-test('JexIR should model intersection types', async () => {
-  await expectJsonSchema($.intersection([$.string(), $.number()])).toEqualJex({
+test('JexIR should model intersection types', () => {
+  expectJsonSchema($.intersection([$.string(), $.number()])).toEqualJex({
     type: 'intersection',
     allOf: [{ type: 'string' }, { type: 'number' }]
   })

jex/src/jexir/from-json-schema.ts

@@ -80,10 +80,6 @@ const _toInternalRep = (path: JSONSchemaPropertyPath, schema: JSONSchema7Definit
     throw new errors.JexUnresolvedReferenceError(path.path)
   }
 
-  if (schema.additionalItems !== undefined) {
-    throw new errors.JexUnsuportedJsonSchemaError(path.path, { additionalItems: schema.additionalItems })
-  }
-
   if (schema.patternProperties !== undefined) {
     throw new errors.JexUnsuportedJsonSchemaError(path.path, { patternProperties: schema.patternProperties })
   }
@@ -146,28 +142,45 @@ const _toInternalRep = (path: JSONSchemaPropertyPath, schema: JSONSchema7Definit
   }
 
   if (schema.type === 'array') {
-    if (schema.items === undefined) {
+    if (schema.additionalItems && schema.items !== undefined) {
+      return {
+        type: 'intersection',
+        allOf: [
+          _toInternalRep(path, { ...schema, additionalItems: undefined }),
+          _toInternalRep(path, { ...schema, items: undefined })
+        ]
+      }
+    }
+
+    if (schema.additionalItems) {
       return {
         type: 'array',
-        items: { type: 'unknown' }
+        items: _toInternalRep(path.key('additionalItems'), schema.additionalItems)
       }
     }
 
-    if (Array.isArray(schema.items)) {
+    if (schema.items !== undefined) {
+      if (Array.isArray(schema.items)) {
+        return {
+          type: 'tuple',
+          items: schema.items.map((s, i) => _toInternalRep(path.key('items').index(i), s))
+        }
+      }
+
       return {
-        type: 'tuple',
-        items: schema.items.map((s, i) => _toInternalRep(path.key('items').index(i), s))
+        type: 'array',
+        items: _toInternalRep(path.key('items'), schema.items)
       }
     }
 
     return {
-      type: 'array',
-      items: _toInternalRep(path.key('items'), schema.items)
+      type: 'tuple',
+      items: []
     }
   }
 
   if (schema.type === 'object') {
-    if (schema.additionalProperties !== undefined && schema.properties !== undefined) {
+    if (schema.additionalProperties && schema.properties !== undefined) {
       return {
         type: 'intersection',
         allOf: [
@@ -177,7 +190,7 @@ const _toInternalRep = (path: JSONSchemaPropertyPath, schema: JSONSchema7Definit
       }
     }
 
-    if (schema.additionalProperties !== undefined) {
+    if (schema.additionalProperties) {
       return {
         type: 'map',
         items: _toInternalRep(path.key('additionalProperties'), schema.additionalProperties)