adapt-octopus 0.1.2 → 0.2.0

package/.github/workflows/new.yml

@@ -16,4 +16,4 @@ jobs:
       - uses: actions/add-to-project@v0.1.0
         with:
           project-url: https://github.com/orgs/adapt-security/projects/5
-          github-token: ${{ secrets.PROJECTS_SECRET }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}

package/.github/workflows/tests.yml

@@ -0,0 +1,15 @@
+name: Tests
+on: push
+jobs:
+  default:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@master
+      - uses: actions/setup-node@master
+        with:
+          node-version: 'lts/*'
+          cache: 'npm'
+      - run: npm ci
+      - run: npm test

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "adapt-octopus",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Convert old Adapt schema into conformant JSON schema",
   "type": "module",
   "main": "./lib/Octopus.js",
@@ -14,6 +14,9 @@
   },
   "homepage": "https://github.com/adapt-security/adapt-octopus#readme",
   "bin": "./bin/cli.js",
+  "scripts": {
+    "test": "node --test 'tests/**/*.spec.js'"
+  },
   "devDependencies": {
     "@semantic-release/git": "^10.0.1",
     "conventional-changelog-eslint": "^6.0.0",

package/tests/Octopus.spec.js

@@ -0,0 +1,349 @@
+import { describe, it, before, after } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs'
+import { join, dirname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import Octopus from '../lib/Octopus.js'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const testDir = join(__dirname, 'temp-test-data')
+
+describe('Octopus', () => {
+  before(() => {
+    // Create test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+    mkdirSync(testDir, { recursive: true })
+  })
+
+  after(() => {
+    // Clean up test directory
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true })
+    }
+  })
+
+  describe('constructor', () => {
+    it('should create an instance with required options', () => {
+      const octopus = new Octopus({
+        inputPath: 'properties.schema',
+        inputId: 'test-component',
+        cwd: testDir
+      })
+      assert.ok(octopus)
+      assert.equal(octopus.inputId, 'test-component')
+    })
+
+    it('should use console as default logger', () => {
+      const octopus = new Octopus({
+        inputPath: 'properties.schema',
+        inputId: 'test-component',
+        cwd: testDir
+      })
+      assert.equal(octopus.logger, console)
+    })
+
+    it('should accept custom logger', () => {
+      const customLogger = { log: () => {} }
+      const octopus = new Octopus({
+        inputPath: 'properties.schema',
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: customLogger
+      })
+      assert.equal(octopus.logger, customLogger)
+    })
+  })
+
+  describe('#start()', () => {
+    it('should throw error if no input path specified', async () => {
+      const octopus = new Octopus({
+        inputId: 'test-component',
+        cwd: testDir
+      })
+      octopus.inputPath = null
+      await assert.rejects(
+        () => octopus.start(),
+        { message: 'No input path specified' }
+      )
+    })
+
+    it('should throw error if no ID specified', async () => {
+      const inputPath = join(testDir, 'test.schema')
+      writeFileSync(inputPath, JSON.stringify({ properties: {} }))
+      const octopus = new Octopus({
+        inputPath,
+        cwd: testDir
+      })
+      await assert.rejects(
+        () => octopus.start(),
+        { message: 'No ID specified' }
+      )
+    })
+
+    it('should load and parse input schema', async () => {
+      const inputPath = join(testDir, 'test-load.schema')
+      const schema = {
+        properties: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      await octopus.start()
+      assert.deepEqual(octopus.inputSchema, schema)
+    })
+  })
+
+  describe('#convert()', () => {
+    it('should handle component schema', async () => {
+      const inputPath = join(testDir, 'component.schema')
+      const schema = {
+        $ref: 'http://localhost/plugins/content/component/model.schema',
+        properties: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      await octopus.start()
+
+      // Check that component schema was created (course schema won't be created with empty properties)
+      const componentSchemaPath = join(testDir, 'schema', 'component.schema.json')
+      assert.ok(existsSync(componentSchemaPath))
+    })
+
+    it('should handle theme schema', async () => {
+      const inputPath = join(testDir, 'theme.schema')
+      const schema = {
+        $ref: 'http://localhost/plugins/content/theme/model.schema',
+        properties: {
+          variables: {
+            primaryColor: { type: 'string' }
+          }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-theme',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      await octopus.start()
+
+      const themeSchemaPath = join(testDir, 'schema', 'theme.schema.json')
+      assert.ok(existsSync(themeSchemaPath))
+    })
+  })
+
+  describe('#construct()', () => {
+    it('should create output schema with SchemaNode', async () => {
+      const inputPath = join(testDir, 'construct-test.schema')
+      const schema = {
+        properties: {
+          title: { type: 'string', title: 'Title' },
+          body: { type: 'string', title: 'Body' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      octopus.inputSchema = schema
+      await octopus.construct('component', schema)
+
+      assert.ok(octopus.outputSchema)
+      assert.equal(octopus.outputSchema.$anchor, 'test-component-component')
+      assert.equal(octopus.outputSchema.$schema, 'https://json-schema.org/draft/2020-12/schema')
+    })
+
+    it('should handle empty properties', async () => {
+      const inputPath = join(testDir, 'empty-test.schema')
+      const schema = { properties: {} }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      octopus.inputSchema = schema
+      await octopus.construct('component', schema)
+
+      // Should not create output for empty properties
+      assert.equal(octopus.outputSchema, undefined)
+    })
+
+    it('should handle course type with globals', async () => {
+      const inputPath = join(testDir, 'globals-test.schema')
+      const schema = {
+        properties: {
+          _id: { type: 'string' }
+        },
+        globals: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      octopus.inputSchema = schema
+      await octopus.construct('course', schema)
+
+      assert.ok(octopus.outputSchema)
+      const properties = octopus.outputSchema.$merge?.with?.properties || octopus.outputSchema.$patch?.with?.properties
+      assert.ok(properties)
+      assert.ok(properties._globals)
+    })
+  })
+
+  describe('#write()', () => {
+    it('should write output schema to file', async () => {
+      const inputPath = join(testDir, 'write-test.schema')
+      const schema = {
+        properties: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      octopus.inputSchema = schema
+      await octopus.construct('component', schema)
+      await octopus.write()
+
+      const outputPath = join(testDir, 'schema', 'component.schema.json')
+      assert.ok(existsSync(outputPath))
+
+      const output = JSON.parse(readFileSync(outputPath, 'utf8'))
+      assert.equal(output.$anchor, 'test-component-component')
+    })
+
+    it('should not overwrite existing schema', async () => {
+      const inputPath = join(testDir, 'no-overwrite.schema')
+      const schema = {
+        properties: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const outputPath = join(testDir, 'schema', 'no-overwrite.schema.json')
+      mkdirSync(dirname(outputPath), { recursive: true })
+      const existingContent = '{"existing": true}'
+      writeFileSync(outputPath, existingContent)
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      octopus.inputSchema = schema
+      await octopus.construct('no-overwrite', schema)
+      octopus.outputPath = outputPath
+      await octopus.write()
+
+      // Should keep existing content
+      const content = readFileSync(outputPath, 'utf8')
+      assert.equal(content, existingContent)
+    })
+
+    it('should log message when writing new schema', async () => {
+      const inputPath = join(testDir, 'log-test.schema')
+      const schema = {
+        properties: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      const octopus = new Octopus({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      octopus.inputSchema = schema
+      await octopus.construct('log-test', schema)
+      await octopus.write()
+
+      assert.ok(logs.some(log => log.includes('converted JSON schema written to')))
+    })
+  })
+
+  describe('.run()', () => {
+    it('should be a static method', () => {
+      assert.equal(typeof Octopus.run, 'function')
+    })
+
+    it('should create instance and start conversion', async () => {
+      const inputPath = join(testDir, 'component.model.schema')
+      const schema = {
+        properties: {
+          title: { type: 'string' }
+        }
+      }
+      writeFileSync(inputPath, JSON.stringify(schema))
+
+      const logs = []
+      await Octopus.run({
+        inputPath,
+        inputId: 'test-component',
+        cwd: testDir,
+        logger: { log: (msg) => logs.push(msg) }
+      })
+
+      const outputPath = join(testDir, 'schema', 'component.schema.json')
+      assert.ok(existsSync(outputPath))
+    })
+  })
+})

package/tests/SchemaNode.spec.js

@@ -0,0 +1,514 @@
+import { describe, it, before } from 'node:test'
+import assert from 'node:assert/strict'
+import SchemaNode from '../lib/SchemaNode.js'
+
+describe('SchemaNode', () => {
+  describe('constructor with nodeType: root', () => {
+    let result
+
+    before(() => {
+      const options = {
+        nodeType: 'root',
+        schemaType: 'config',
+        inputId: 'adapt-test',
+        inputSchema: {
+          properties: {
+            title: { type: 'string', required: true },
+            body: { type: 'string' }
+          }
+        },
+        logger: { log: () => {} }
+      }
+      result = new SchemaNode(options)
+    })
+
+    it('should create a root schema with $anchor', () => {
+      assert.equal(result.$anchor, 'adapt-test-config')
+    })
+
+    it('should have $schema property', () => {
+      assert.equal(result.$schema, 'https://json-schema.org/draft/2020-12/schema')
+    })
+
+    it('should have type object', () => {
+      assert.equal(result.type, 'object')
+    })
+
+    it('should have $patch for extension schemas', () => {
+      assert.ok(result.$patch)
+      assert.equal(result.$patch.source.$ref, 'config')
+    })
+
+    it('should have properties in $patch.with', () => {
+      assert.ok(result.$patch.with.properties)
+    })
+  })
+
+  describe('constructor with nodeType: root (core component)', () => {
+    let result
+
+    before(() => {
+      const options = {
+        nodeType: 'root',
+        schemaType: 'component',
+        inputId: 'component',
+        inputSchema: {
+          properties: {
+            title: { type: 'string' }
+          }
+        },
+        logger: { log: () => {} }
+      }
+      result = new SchemaNode(options)
+    })
+
+    it('should use $merge for core components', () => {
+      assert.ok(result.$merge)
+      assert.equal(result.$merge.source.$ref, 'content')
+    })
+
+    it('should have correct $anchor for core component', () => {
+      assert.equal(result.$anchor, 'component')
+    })
+  })
+
+  describe('constructor with nodeType: properties', () => {
+    let result
+
+    before(() => {
+      const options = {
+        nodeType: 'properties',
+        key: 'title',
+        inputSchema: {
+          type: 'string',
+          title: 'Title',
+          help: 'The title text',
+          default: '',
+          translatable: true
+        },
+        logger: { log: () => {} }
+      }
+      result = new SchemaNode(options)
+    })
+
+    it('should have correct type', () => {
+      assert.equal(result.type, 'string')
+    })
+
+    it('should have title', () => {
+      assert.equal(result.title, 'Title')
+    })
+
+    it('should have description from help', () => {
+      assert.equal(result.description, 'The title text')
+    })
+
+    it('should have default value', () => {
+      assert.equal(result.default, '')
+    })
+
+    it('should have _adapt options', () => {
+      assert.deepEqual(result._adapt, { translatable: true })
+    })
+  })
+
+  describe('#getType()', () => {
+    it('should return the type for regular types', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.type, 'string')
+    })
+
+    it('should keep objectid type and set isObjectId flag', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'objectid' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.type, 'objectid')
+      assert.equal(node.isObjectId, true)
+    })
+  })
+
+  describe('#getTitle()', () => {
+    it('should return title if provided', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', title: 'Custom Title' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.title, 'Custom Title')
+    })
+
+    it('should return legend if title not provided', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', legend: 'Legend Text' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.title, 'Legend Text')
+    })
+
+    it('should generate title from key', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'displayTitle',
+        inputSchema: { type: 'string' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.title, 'Display title')
+    })
+
+    it('should handle underscores in key', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'user_name',
+        inputSchema: { type: 'string' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.title, 'Username')
+    })
+  })
+
+  describe('#getDefault()', () => {
+    it('should return explicit default if provided', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', default: 'custom' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.default, 'custom')
+    })
+
+    it('should return empty string for non-required string', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.default, '')
+    })
+
+    it('should return 0 for non-required number', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'number' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.default, 0)
+    })
+
+    it('should return false for non-required boolean', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'boolean' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.default, false)
+    })
+
+    it('should return empty object for non-required object', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'object' },
+        logger: { log: () => {} }
+      })
+      assert.deepEqual(node.default, {})
+    })
+
+    it('should return empty array for non-required array without items', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'array' },
+        logger: { log: () => {} }
+      })
+      assert.deepEqual(node.default, [])
+    })
+
+    it('should not return default for required fields', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', required: true },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.default, undefined)
+    })
+
+    it('should not return default for ObjectId fields', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'objectid' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.default, undefined)
+    })
+  })
+
+  describe('#getIsObjectId()', () => {
+    it('should return true for objectid type', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'objectid' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.isObjectId, true)
+    })
+
+    it('should return true for Asset inputType', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', inputType: 'Asset:image' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.isObjectId, true)
+    })
+
+    it('should return undefined for regular types', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.isObjectId, undefined)
+    })
+  })
+
+  describe('#getRequiredFields()', () => {
+    it('should return required field names', () => {
+      const node = new SchemaNode({
+        nodeType: 'root',
+        schemaType: 'test',
+        inputId: 'test',
+        inputSchema: {
+          properties: {
+            title: { type: 'string', required: true },
+            body: { type: 'string' },
+            subtitle: { type: 'string', validators: ['required'] }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      // For root nodes, required is in $merge.with.required (core) or $patch.with.required (extension)
+      const required = node.$merge?.with?.required || node.$patch?.with?.required
+      assert.deepEqual(required, ['title', 'subtitle'])
+    })
+
+    it('should exclude fields with default values', () => {
+      const node = new SchemaNode({
+        nodeType: 'root',
+        schemaType: 'test',
+        inputId: 'test',
+        inputSchema: {
+          properties: {
+            title: { type: 'string', required: true, default: 'test' },
+            body: { type: 'string', required: true }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      const required = node.$merge?.with?.required || node.$patch?.with?.required
+      assert.deepEqual(required, ['body'])
+    })
+
+    it('should return undefined if no required fields', () => {
+      const node = new SchemaNode({
+        nodeType: 'root',
+        schemaType: 'test',
+        inputId: 'test',
+        inputSchema: {
+          properties: {
+            title: { type: 'string' },
+            body: { type: 'string' }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      const required = node.$merge?.with?.required || node.$patch?.with?.required
+      assert.equal(required, undefined)
+    })
+  })
+
+  describe('#getProperties()', () => {
+    it('should return undefined if no properties or globals', () => {
+      const node = new SchemaNode({
+        nodeType: 'root',
+        schemaType: 'test',
+        inputId: 'test',
+        inputSchema: {},
+        logger: { log: () => {} }
+      })
+      const properties = node.$merge?.with?.properties || node.$patch?.with?.properties || node.properties
+      assert.equal(properties, undefined)
+    })
+
+    it('should convert properties to SchemaNode instances', () => {
+      const node = new SchemaNode({
+        nodeType: 'root',
+        schemaType: 'test',
+        inputId: 'test',
+        inputSchema: {
+          properties: {
+            title: { type: 'string' }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      const properties = node.$merge?.with?.properties || node.$patch?.with?.properties
+      assert.ok(properties.title)
+      assert.equal(properties.title.type, 'string')
+    })
+
+    it('should handle globals', () => {
+      const node = new SchemaNode({
+        nodeType: 'root',
+        schemaType: 'course',
+        inputId: 'test-plugin',
+        inputSchema: {
+          globals: {
+            title: { type: 'string', default: 'Global Title' }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      const properties = node.$merge?.with?.properties || node.$patch?.with?.properties
+      assert.ok(properties._globals)
+      assert.equal(properties._globals.type, 'object')
+      assert.ok(properties._globals.properties['_test-plugin'])
+    })
+  })
+
+  describe('#getEnumeratedValues()', () => {
+    it('should return originalEnum if provided', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', originalEnum: ['a', 'b', 'c'] },
+        logger: { log: () => {} }
+      })
+      assert.deepEqual(node.enum, ['a', 'b', 'c'])
+    })
+
+    it('should return Select options', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'string', inputType: { type: 'Select', options: ['x', 'y'] } },
+        logger: { log: () => {} }
+      })
+      assert.deepEqual(node.enum, ['x', 'y'])
+    })
+  })
+
+  describe('#getAdaptOptions()', () => {
+    it('should return adapt options', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: {
+          type: 'string',
+          editorOnly: true,
+          isSetting: true,
+          translatable: true
+        },
+        logger: { log: () => {} }
+      })
+      assert.deepEqual(node._adapt, {
+        editorOnly: true,
+        isSetting: true,
+        translatable: true
+      })
+    })
+
+    it('should strip undefined values', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: {
+          type: 'string',
+          translatable: true
+        },
+        logger: { log: () => {} }
+      })
+      assert.deepEqual(node._adapt, { translatable: true })
+    })
+  })
+
+  describe('constructor with nodeType: items', () => {
+    it('should handle items with properties', () => {
+      const node = new SchemaNode({
+        nodeType: 'items',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            label: { type: 'string' },
+            value: { type: 'string' }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.type, 'object')
+      assert.ok(node.properties)
+      assert.ok(node.properties.label)
+      assert.ok(node.properties.value)
+    })
+
+    it('should handle items without properties', () => {
+      const node = new SchemaNode({
+        nodeType: 'items',
+        inputSchema: {},
+        logger: { log: () => {} }
+      })
+      assert.equal(node.type, 'object')
+      assert.equal(node.properties, undefined)
+    })
+  })
+
+  describe('#getItems()', () => {
+    it('should return items SchemaNode if items exist', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              label: { type: 'string' }
+            }
+          }
+        },
+        logger: { log: () => {} }
+      })
+      assert.ok(node.items)
+      assert.equal(node.items.type, 'object')
+    })
+
+    it('should return undefined if no items', () => {
+      const node = new SchemaNode({
+        nodeType: 'properties',
+        key: 'test',
+        inputSchema: { type: 'array' },
+        logger: { log: () => {} }
+      })
+      assert.equal(node.items, undefined)
+    })
+  })
+})

package/tests/data/sample-schema.json

@@ -0,0 +1,29 @@
+{
+  "type": "object",
+  "properties": {
+    "title": {
+      "type": "string",
+      "title": "Title",
+      "help": "The title of the component",
+      "default": "",
+      "translatable": true
+    },
+    "body": {
+      "type": "string",
+      "title": "Body",
+      "help": "The main body text",
+      "default": "",
+      "translatable": true
+    },
+    "isEnabled": {
+      "type": "boolean",
+      "title": "Is Enabled",
+      "default": true
+    },
+    "count": {
+      "type": "number",
+      "title": "Count",
+      "default": 0
+    }
+  }
+}

package/tests/stripObject.spec.js

@@ -0,0 +1,65 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import stripObject from '../utils/stripObject.js'
+
+describe('stripObject', () => {
+  describe('with undefined values', () => {
+    it('should remove undefined properties', () => {
+      const obj = { a: 1, b: undefined, c: 'test' }
+      const result = stripObject(obj)
+      assert.deepEqual(result, { a: 1, c: 'test' })
+    })
+
+    it('should return undefined if all properties are undefined', () => {
+      const obj = { a: undefined, b: undefined }
+      const result = stripObject(obj)
+      assert.equal(result, undefined)
+    })
+
+    it('should return the object if no properties are undefined', () => {
+      const obj = { a: 1, b: 'test', c: true }
+      const result = stripObject(obj)
+      assert.deepEqual(result, { a: 1, b: 'test', c: true })
+    })
+  })
+
+  describe('with null and falsy values', () => {
+    it('should not remove null values', () => {
+      const obj = { a: null, b: 1 }
+      const result = stripObject(obj)
+      assert.deepEqual(result, { a: null, b: 1 })
+    })
+
+    it('should not remove false values', () => {
+      const obj = { a: false, b: 1 }
+      const result = stripObject(obj)
+      assert.deepEqual(result, { a: false, b: 1 })
+    })
+
+    it('should not remove zero values', () => {
+      const obj = { a: 0, b: 1 }
+      const result = stripObject(obj)
+      assert.deepEqual(result, { a: 0, b: 1 })
+    })
+
+    it('should not remove empty string values', () => {
+      const obj = { a: '', b: 1 }
+      const result = stripObject(obj)
+      assert.deepEqual(result, { a: '', b: 1 })
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle empty objects', () => {
+      const obj = {}
+      const result = stripObject(obj)
+      assert.equal(result, undefined)
+    })
+
+    it('should mutate the original object', () => {
+      const obj = { a: 1, b: undefined }
+      stripObject(obj)
+      assert.deepEqual(obj, { a: 1 })
+    })
+  })
+})