@travetto/schema 2.0.2 → 2.1.0

package/README.md

@@ -65,23 +65,24 @@ This schema provides a powerful base for data binding and validation at runtime.
 
    
    *  [@Field](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L38) defines a field that will be serialized.
-   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L60) defines a that field should be required
-   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L67) defines the allowable values that a field can have
-   *  [@Trimmed](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L76) augments binding to remove leading and trailing whitespace from string values
-   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L94) defines a regular expression that the field value should match
-   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L102) enforces min length of a string
-   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L110) enforces max length of a string
-   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L102) enforces min value for a date or a number
-   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L110) enforces max value for a date or a number
-   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L133) ensures string field matches basic email regex
-   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L140) ensures string field matches basic telephone regex
-   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L147) ensures string field matches basic url regex
-   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L186) exclude from auto schema registration
-   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L161) ensures number passed in is only a whole number
-   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L167) ensures number passed in allows fractional values
-   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L179) provides support for standard currency
-   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L81) indicates that a field is expecting natural language input, not just discrete values
-   *  [@LongText](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L86) same as text, but expects longer form content
+   *  [@Required](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L72) defines a that field should be required
+   *  [@Enum](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L79) defines the allowable values that a field can have
+   *  [@Match](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L100) defines a regular expression that the field value should match
+   *  [@MinLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L108) enforces min length of a string
+   *  [@MaxLength](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) enforces max length of a string
+   *  [@Min](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L108) enforces min value for a date or a number
+   *  [@Max](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L116) enforces max value for a date or a number
+   *  [@Email](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L139) ensures string field matches basic email regex
+   *  [@Telephone](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L146) ensures string field matches basic telephone regex
+   *  [@Url](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L153) ensures string field matches basic url regex
+   *  [@Ignore](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L192) exclude from auto schema registration
+   *  [@Integer](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L167) ensures number passed in is only a whole number
+   *  [@Float](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L173) ensures number passed in allows fractional values
+   *  [@Currency](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L185) provides support for standard currency
+   *  [@Text](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L87) indicates that a field is expecting natural language input, not just discrete values
+   *  [@LongText](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L92) same as text, but expects longer form content
+   *  [@Readonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L65) defines a that field should not be bindable external to the class
+   *  [@Writeonly](https://github.com/travetto/travetto/tree/main/module/schema/src/decorator/field.ts#L59) defines a that field should not be exported in serialization, but that it can be bound to
 
 Additionally, schemas can be nested to form more complex data structures that are able to bound and validated.
 
@@ -205,7 +206,7 @@ Validation Failed {
   "message": "Validation errors have occurred",
   "category": "data",
   "type": "ValidationResultError",
-  "at": "2021-03-14T05:00:00.618Z",
+  "at": "2022-03-14T04:00:00.618Z",
   "errors": [
     {
       "kind": "type",
@@ -434,7 +435,7 @@ Validation Failed {
   "message": "Validation errors have occurred",
   "category": "data",
   "type": "ValidationResultError",
-  "at": "2021-03-14T05:00:00.837Z",
+  "at": "2022-03-14T04:00:00.837Z",
   "errors": [
     {
       "kind": "type",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/schema",
   "displayName": "Schema",
-  "version": "2.0.2",
+  "version": "2.1.0",
   "description": "Data type registry for runtime validation, reflection and binding. ",
   "keywords": [
     "schema",
@@ -29,11 +29,11 @@
     "directory": "module/schema"
   },
   "dependencies": {
-    "@travetto/registry": "^2.0.1",
-    "@travetto/transformer": "^2.0.1"
+    "@travetto/registry": "^2.1.0",
+    "@travetto/transformer": "^2.1.0"
   },
   "optionalPeerDependencies": {
-    "@types/faker": "^5.5.6",
+    "@types/faker": "^5.5.9",
     "faker": "^5.5.3"
   },
   "publishConfig": {

package/src/bind-util.ts

@@ -149,6 +149,8 @@ export class BindUtil {
       return data as T;
     } else {
       const tgt = new (cls as ConcreteClass<T>)();
+      SchemaRegistry.ensureInstanceTypeField(cls, tgt);
+
       for (const [k, v] of Object.entries(tgt)) { // Do not retain undefined fields
         if (v === undefined) {
           delete tgt[k as keyof T];
@@ -185,7 +187,9 @@ export class BindUtil {
 
         for (const schemaFieldName of viewConf.fields) {
           let inboundField: string | undefined = undefined;
-
+          if (viewConf.schema[schemaFieldName].access === 'readonly') {
+            continue; // Skip trying to write readonly fields
+          }
           if (schemaFieldName in data) {
             inboundField = schemaFieldName;
           } else if (viewConf.schema[schemaFieldName].aliases) {

package/src/decorator/field.ts

@@ -4,8 +4,8 @@ import { SchemaRegistry } from '../service/registry';
 import { CommonRegExp } from '../validate/regexp';
 import { ClassList, FieldConfig } from '../service/types';
 
-function prop(obj: Record<string, unknown>) {
-  return (t: ClassInstance, k: string, idx?: number) => {
+function prop(obj: Partial<FieldConfig>) {
+  return (t: ClassInstance, k: string, idx?: number | PropertyDescriptor) => {
     if (idx !== undefined && typeof idx === 'number') {
       SchemaRegistry.registerPendingParamFacet(t.constructor, k, idx, obj);
     } else {
@@ -15,19 +15,19 @@ function prop(obj: Record<string, unknown>) {
 }
 
 const stringArrProp = prop as
-  (obj: Record<string, unknown>) => <T extends Partial<Record<K, string | unknown[]>>, K extends string>(t: T, k: K, idx?: number) => void;
+  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | unknown[]>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
 
 const stringArrStringProp = prop as
-  (obj: Record<string, unknown>) => <T extends Partial<Record<K, string | string[]>>, K extends string>(t: T, k: K, idx?: number) => void;
+  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | string[]>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
 
 const numberProp = prop as
-  (obj: Record<string, unknown>) => <T extends Partial<Record<K, number>>, K extends string>(t: T, k: K, idx?: number) => void;
+  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
 
 const stringNumberProp = prop as
-  (obj: Record<string, unknown>) => <T extends Partial<Record<K, string | number>>, K extends string>(t: T, k: K, idx?: number) => void;
+  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, string | number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
 
 const dateNumberProp = prop as
-  (obj: Record<string, unknown>) => <T extends Partial<Record<K, Date | number>>, K extends string>(t: T, k: K, idx?: number) => void;
+  (obj: Partial<FieldConfig>) => <T extends Partial<Record<K, Date | number>>, K extends string>(t: T, k: K, idx?: number | PropertyDescriptor) => void;
 
 /**
  * Registering a field
@@ -36,7 +36,7 @@ const dateNumberProp = prop as
  * @augments `@trv:schema/Field`
  */
 export function Field(type: ClassList, config?: Partial<FieldConfig>) {
-  return (f: ClassInstance, k: string, idx?: number) => {
+  return (f: ClassInstance, k: string, idx?: number | PropertyDescriptor) => {
     if (idx !== undefined && typeof idx === 'number') {
       SchemaRegistry.registerPendingParamConfig(f.constructor, k, idx, type, config);
     } else {
@@ -51,6 +51,18 @@ export function Field(type: ClassList, config?: Partial<FieldConfig>) {
  * @augments `@trv:schema/Field`
  */
 export function Alias(...aliases: string[]) { return prop({ aliases }); }
+/**
+ * Mark a field as writeonly
+ * @param active This determines if this field is readonly or not.
+ * @augments `@trv:schema/Field`
+ */
+export function Writeonly(active = true) { return prop({ access: 'writeonly' }); }
+/**
+ * Mark a field as readonly
+ * @param active This determines if this field is readonly or not.
+ * @augments `@trv:schema/Field`
+ */
+export function Readonly(active = true) { return prop({ access: 'readonly' }); }
 /**
  * Mark a field as required
  * @param active This determines if this field is required or not.
@@ -68,12 +80,6 @@ export function Enum(values: string[], message?: string) {
   message = message || `{path} is only allowed to be "${values.join('" or "')}"`;
   return stringNumberProp({ enum: { values, message } });
 }
-
-/**
- * Should the field be trimmed on storage
- * @augments `@trv:schema/Field`
- */
-export function Trimmed() { return stringArrStringProp({ trim: true }); }
 /**
  * Mark the field as indicating it's storing textual data
  * @augments `@trv:schema/Field`

package/src/decorator/schema.ts

@@ -36,4 +36,15 @@ export function View<T>(name: string, fields: ViewFieldsConfig<Partial<T>>) {
   return (target: Class<Partial<T>>) => {
     SchemaRegistry.registerPendingView(target, name, fields);
   };
+}
+
+/**
+ * Register a class as a subtype, with a specific discriminator
+ * @param name
+ * @returns
+ */
+export function SubType<T>(name: string) {
+  return (target: Class<Partial<T>>) => {
+    SchemaRegistry.registerSubTypes(target, name);
+  };
 }

package/src/service/registry.ts

@@ -24,6 +24,36 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     super(RootRegistry);
   }
 
+  #computeSubTypeName(cls: Class) {
+    if (!this.#typeKeys.has(cls)) {
+      this.#typeKeys.set(cls, cls.name
+        .replace(/([A-Z])([A-Z][a-z])/g, (all, l, r) => `${l}_${r.toLowerCase()}`)
+        .replace(/([a-z]|\b)([A-Z])/g, (all, l, r) => l ? `${l}_${r.toLowerCase()}` : r.toLowerCase())
+        .toLowerCase());
+    }
+    return this.#typeKeys.get(cls);
+  }
+
+  /**
+   * Get subtype name for a class
+   * @param cls Base class
+   */
+  getSubTypeName(cls: Class) {
+    if (this.get(cls).subType) {
+      return this.#computeSubTypeName(cls);
+    }
+  }
+
+  /**
+   * Ensure type is set properl
+   */
+  ensureInstanceTypeField<T>(cls: Class, o: T) {
+    const withType = (o as { type?: string });
+    if (this.get(cls)?.subType && 'type' in this.get(cls).views[AllViewⲐ].schema && !withType.type) {  // Do we have a type field defined
+      withType.type = this.#computeSubTypeName(cls); // Assign if missing
+    }
+  }
+
   /**
    * Find the subtype for a given instance
    * @param cls Class for instance
@@ -44,7 +74,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       if (type) {
         return this.#subTypes.get(cls)!.get(typeId) ?? cls;
       }
-    } else {
+    } else if (this.get(cls)?.subType) {
       const expectedType = this.#typeKeys.get(cls);
       if (expectedType && typeof type === 'string' && expectedType !== type) {
         throw new AppError(`Data of type ${type} does not match expected class type ${expectedType}`, 'data');
@@ -53,23 +83,19 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     return cls;
   }
 
-  /**
-   * Get subtype name for a class
-   * @param cls Base class
-   */
-  getSubTypeName(cls: Class) {
-    return cls.name
-      .replace(/([A-Z])([A-Z][a-z])/g, (all, l, r) => `${l}_${r.toLowerCase()}`)
-      .replace(/([a-z]|\b)([A-Z])/g, (all, l, r) => l ? `${l}_${r.toLowerCase()}` : r.toLowerCase())
-      .toLowerCase();
-  }
-
   /**
    * Register sub types for a class
    * @param cls The class to register against
    * @param type The subtype name
    */
-  registerSubTypes(cls: Class, type: string) {
+  registerSubTypes(cls: Class, type?: string) {
+    // Mark as subtype
+    (this.get(cls) ?? this.getOrCreatePending(cls)).subType = true;
+
+    type ??= this.#computeSubTypeName(cls)!;
+
+    this.#typeKeys.set(cls, type);
+
     let parent = this.getParentClass(cls)!;
     let parentConfig = this.get(parent);
 
@@ -77,12 +103,13 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       if (!this.#subTypes.has(parent)) {
         this.#subTypes.set(parent, new Map());
       }
-      this.#typeKeys.set(cls, type);
       this.#subTypes.get(parent)!.set(type, cls);
       this.#subTypes.get(parent)!.set(cls.ᚕid, cls);
       parent = this.getParentClass(parent!)!;
       parentConfig = this.get(parent);
     }
+
+    return type;
   }
 
   /**
@@ -109,6 +136,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     return {
       class: cls,
       validators: [],
+      subType: false,
       views: {
         [AllViewⲐ]: {
           schema: {},
@@ -259,6 +287,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       schema: { ...dest.views[AllViewⲐ].schema, ...src.views[AllViewⲐ].schema },
       fields: [...dest.views[AllViewⲐ].fields, ...src.views[AllViewⲐ].fields]
     };
+    dest.subType = src.subType || dest.subType;
     dest.title = src.title || dest.title;
     dest.validators = [...src.validators, ...dest.validators];
     return dest;
@@ -305,7 +334,7 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
       }
     }
 
-    this.registerSubTypes(cls, this.getSubTypeName(cls));
+    this.registerSubTypes(cls);
 
     // Merge pending, back on top, to allow child to have higher precedence
     const pending = this.getOrCreatePending(cls);
@@ -332,10 +361,13 @@ class $SchemaRegistry extends MetadataRegistry<ClassConfig, FieldConfig> {
     if (e.type === 'removing' && this.hasExpired(cls)) {
       // Recompute subtypes
       this.#subTypes.clear();
+      this.#typeKeys.delete(cls);
       this.#methodSchemas.delete(cls);
+
+      // Recompute subtype mappings
       for (const el of this.entries.keys()) {
         const clz = this.entries.get(el)!.class;
-        this.registerSubTypes(clz, this.getSubTypeName(clz));
+        this.registerSubTypes(clz);
       }
 
       SchemaChangeListener.clearSchemaDependency(cls);

package/src/service/types.ts

@@ -64,6 +64,10 @@ export interface ClassConfig extends DescribableConfig {
    * Global validators
    */
   validators: ValidatorFn<unknown, unknown>[];
+  /**
+   * Is the class a sub type
+   */
+  subType?: boolean;
 }
 
 /**
@@ -141,6 +145,10 @@ export interface FieldConfig extends DescribableConfig {
    * Default value
    */
   default?: Primitive;
+  /**
+   * Is the field readonly, or write only?, defaults to no restrictions
+   */
+  access?: 'readonly' | 'writeonly';
 }
 
 export type ViewFieldsConfig<T> = { with: (keyof T)[] } | { without: (keyof T)[] };

package/src/validate/validator.ts

@@ -38,7 +38,9 @@ export class SchemaValidator {
     let errors: ValidationError[] = [];
 
     for (const field of Object.keys(schema)) {
-      errors = errors.concat(this.#validateFieldSchema(schema[field], o[field as keyof T], relative));
+      if (schema[field].access !== 'readonly') { // Do not validate readonly fields
+        errors = errors.concat(this.#validateFieldSchema(schema[field], o[field as keyof T], relative));
+      }
     }
 
     return errors;
@@ -223,7 +225,7 @@ export class SchemaValidator {
    * @param view The optional view to limit the scope to
    */
   static async validate<T>(cls: Class<T>, o: T, view?: string): Promise<T> {
-    if (!Util.isPlainObject(o) && !(o instanceof cls)) {
+    if (!Util.isPlainObject(o) && !(o instanceof cls || cls.ᚕid === (o as ClassInstance<T>).constructor.ᚕid)) {
       throw new TypeMismatchError(cls.name, (o as unknown as ClassInstance).constructor.name);
     }
     cls = SchemaRegistry.resolveSubTypeForInstance(cls, o);

package/support/transform-util.ts

@@ -65,15 +65,33 @@ export class SchemaTransformUtil {
   /**
    * Compute property information from declaration
    */
-  static computeField<T extends ts.PropertyDeclaration | ts.ParameterDeclaration>(
+  static computeField<T extends ts.PropertyDeclaration | ts.ParameterDeclaration | ts.GetAccessorDeclaration | ts.SetAccessorDeclaration>(
     state: TransformerState, node: T, config: { type?: AnyType, root?: ts.Node, name?: string } = { root: node }
   ): T {
 
-    const typeExpr = config.type ?? state.resolveType(node);
+    const typeExpr = config.type ?? state.resolveType(ts.isSetAccessor(node) ? node.parameters[0] : node);
     const attrs: ts.PropertyAssignment[] = [];
 
-    if (!node.questionToken && !typeExpr.undefinable && !node.initializer) {
-      attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
+    if (!ts.isGetAccessorDeclaration(node) && !ts.isSetAccessorDeclaration(node)) {
+      // eslint-disable-next-line no-bitwise
+      if ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Readonly) > 0) {
+        attrs.push(state.factory.createPropertyAssignment('mode', state.fromLiteral('readonly')));
+      } else if (!node.questionToken && !typeExpr.undefinable && !node.initializer) {
+        attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
+      }
+      if (node.initializer && ts.isLiteralExpression(node.initializer)) {
+        attrs.push(state.factory.createPropertyAssignment('default', node.initializer));
+      }
+    } else {
+      const acc = DeclarationUtil.getAccessorPair(node);
+      if (!acc.setter) {
+        attrs.push(state.factory.createPropertyAssignment('access', state.fromLiteral('readonly')));
+      }
+      if (!acc.getter) {
+        attrs.push(state.factory.createPropertyAssignment('mode', state.fromLiteral('writeonly')));
+      } else if (!typeExpr.undefinable) {
+        attrs.push(state.factory.createPropertyAssignment('required', state.fromLiteral({ active: true })));
+      }
     }
 
     if (ts.isParameter(node) || config.name !== undefined) {
@@ -82,10 +100,6 @@ export class SchemaTransformUtil {
       ));
     }
 
-    if (node.initializer && ts.isLiteralExpression(node.initializer)) {
-      attrs.push(state.factory.createPropertyAssignment('default', node.initializer));
-    }
-
     // If we have a union type
     if (typeExpr.key === 'union') {
       const values = typeExpr.subTypes.map(x => x.key === 'literal' ? x.value : undefined)
@@ -135,23 +149,16 @@ export class SchemaTransformUtil {
       }
 
       return state.factory.updatePropertyDeclaration(node as Exclude<typeof node, T>,
-        newDecs,
-        node.modifiers,
-        node.name,
-        node.questionToken,
-        node.type,
-        node.initializer
-      ) as T;
-    } else {
+        newDecs, node.modifiers, node.name, node.questionToken, node.type, node.initializer) as T;
+    } else if (ts.isParameter(node)) {
       return state.factory.updateParameterDeclaration(node as Exclude<typeof node, T>,
-        newDecs,
-        node.modifiers,
-        node.dotDotDotToken,
-        node.name,
-        node.questionToken,
-        node.type,
-        node.initializer
-      ) as T;
+        newDecs, node.modifiers, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) as T;
+    } else if (ts.isGetAccessorDeclaration(node)) {
+      return state.factory.updateGetAccessorDeclaration(node as Exclude<typeof node, T>,
+        newDecs, node.modifiers, node.name, node.parameters, node.type, node.body) as T;
+    } else {
+      return state.factory.updateSetAccessorDeclaration(node as Exclude<typeof node, T>,
+        newDecs, node.modifiers, node.name, node.parameters, node.body) as T;
     }
   }
 

package/support/transformer.schema.ts

@@ -1,14 +1,17 @@
 import * as ts from 'typescript';
 
 import {
-  TransformerState, OnProperty, OnClass, AfterClass, DecoratorMeta, DocUtil, DeclarationUtil, TransformerId
+  TransformerState, OnProperty, OnClass, AfterClass, DecoratorMeta, DocUtil, DeclarationUtil, TransformerId, OnGetter, OnSetter
 } from '@travetto/transformer';
+
 import { SchemaTransformUtil } from './transform-util';
 
 const inSchema = Symbol.for('@trv:schema/schema');
+const accessors = Symbol.for('@trv:schema/schema');
 
 interface AutoState {
   [inSchema]?: boolean;
+  [accessors]?: Set<string>;
 }
 
 const SCHEMA_MOD = '@travetto/schema/src/decorator/schema';
@@ -27,6 +30,7 @@ export class SchemaTransformer {
   @OnClass('Schema')
   static startSchema(state: AutoState & TransformerState, node: ts.ClassDeclaration, dec?: DecoratorMeta) {
     state[inSchema] = true;
+    state[accessors] = new Set();
     return node;
   }
 
@@ -50,6 +54,7 @@ export class SchemaTransformer {
     }
 
     delete state[inSchema];
+    delete state[accessors];
 
     return state.factory.updateClassDeclaration(
       node,
@@ -71,4 +76,30 @@ export class SchemaTransformer {
     return state[inSchema] && !ignore && DeclarationUtil.isPublic(node) ?
       SchemaTransformUtil.computeField(state, node) : node;
   }
+
+  /**
+   * Handle getters
+   */
+  @OnGetter()
+  static processSchemaGetter(state: TransformerState & AutoState, node: ts.GetAccessorDeclaration) {
+    const ignore = state.findDecorator(this, node, 'Ignore');
+    if (state[inSchema] && !ignore && DeclarationUtil.isPublic(node) && !state[accessors]?.has(node.name.getText())) {
+      state[accessors]?.add(node.name.getText());
+      return SchemaTransformUtil.computeField(state, node);
+    }
+    return node;
+  }
+
+  /**
+   * Handle setters
+   */
+  @OnSetter()
+  static processSchemaSetter(state: TransformerState & AutoState, node: ts.SetAccessorDeclaration) {
+    const ignore = state.findDecorator(this, node, 'Ignore');
+    if (state[inSchema] && !ignore && DeclarationUtil.isPublic(node) && !state[accessors]?.has(node.name.getText())) {
+      state[accessors]?.add(node.name.getText());
+      return SchemaTransformUtil.computeField(state, node);
+    }
+    return node;
+  }
 }