feat: add simplified channel parameter

src/models/v3/channel-parameter.ts

@@ -1,12 +1,10 @@
 import { BaseModel } from '../base';
-import { Schema } from './schema';
-
 import { hasDescription, description, extensions } from './mixins';
+import { Schema } from './schema';
 
 import type { ChannelParameterInterface } from '../channel-parameter';
 import type { SchemaInterface } from '../schema';
 import type { ExtensionsInterface } from '../extensions';
-
 import type { v3 } from '../../spec-types';
 
 export class ChannelParameter extends BaseModel<v3.ParameterObject, { id: string }> implements ChannelParameterInterface {
@@ -15,12 +13,23 @@ export class ChannelParameter extends BaseModel<v3.ParameterObject, { id: string
   }
 
   hasSchema(): boolean {
-    return !!this._json.schema;
+    return this._json && (
+      this._json.description !== undefined ||
+      this._json.default !== undefined || 
+      this._json.enum !== undefined || 
+      this._json.examples !== undefined
+    );
   }
 
   schema(): SchemaInterface | undefined {
-    if (!this._json.schema) return undefined;
-    return this.createModel(Schema, this._json.schema, { pointer: `${this._meta.pointer}/schema` });
+    if (!this.hasSchema()) return undefined;
+    return this.createModel(Schema, {
+      type: 'string', 
+      description: this._json.description,
+      enum: this._json.enum, 
+      default: this._json.default, 
+      examples: this._json.examples
+    }, { pointer: `${this._meta.pointer}` });
   }
 
   hasLocation(): boolean {

src/spec-types/v3.ts

@@ -226,7 +226,9 @@ export type ParametersObject = Record<string, ParameterObject | ReferenceObject>
 
 export interface ParameterObject extends SpecificationExtensions {
   description?: string;
-  schema?: SchemaObject;
+  enum?: string[];
+  default?: string;
+  examples?: string[];
   location?: string;
 }
 

test/models/v3/channel-parameter.spec.ts

@@ -43,12 +43,23 @@ describe('ChannelParameter model', function() {
   });
 
   describe('.hasSchema()', function() {
-    it('should return true when there is a value', function() {
-      const doc = serializeInput<v3.ParameterObject>({ schema: {} });
+    it('should return true if enum are sat', function() {
+      const doc = serializeInput<v3.ParameterObject>({ enum: ['test'] });
+      const d = new ChannelParameter(doc);
+      expect(d.hasSchema()).toEqual(true);
+    });
+    it('should return true if default are sat', function() {
+      const doc = serializeInput<v3.ParameterObject>({ default: 'test' });
       const d = new ChannelParameter(doc);
       expect(d.hasSchema()).toEqual(true);
     });
 
+    it('should return true if examples are sat', function() {
+      const doc = serializeInput<v3.ParameterObject>({ examples: ['test'] });
+      const d = new ChannelParameter(doc);
+      expect(d.hasSchema()).toEqual(true);
+    });
+
     it('should return false when there is no value', function() {
       const doc = serializeInput<v3.ParameterObject>({});
       const d = new ChannelParameter(doc);
@@ -57,10 +68,23 @@ describe('ChannelParameter model', function() {
   });
 
   describe('.schema()', function() {
-    it('should return the value', function() {
-      const doc = serializeInput<v3.ParameterObject>({ schema: {} });
+    it('should be able to access enum values', function() {
+      const doc = serializeInput<v3.ParameterObject>({ enum: ['test'] });
+      const d = new ChannelParameter(doc);
+      expect(d.schema()).toBeInstanceOf(Schema);
+      expect(d.schema()?.enum()).toEqual(['test']);
+    });
+    it('should be able to access examples values', function() {
+      const doc = serializeInput<v3.ParameterObject>({ examples: ['test'] });
+      const d = new ChannelParameter(doc);
+      expect(d.schema()).toBeInstanceOf(Schema);
+      expect(d.schema()?.examples()).toEqual(['test']);
+    });
+    it('should be able to access default value', function() {
+      const doc = serializeInput<v3.ParameterObject>({ default: 'test' });
       const d = new ChannelParameter(doc);
       expect(d.schema()).toBeInstanceOf(Schema);
+      expect(d.schema()?.default()).toEqual('test');
     });
 
     it('should return undefined when there is no value', function() {