@travetto/model 8.0.0-alpha.20 → 8.0.0-alpha.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model",
-  "version": "8.0.0-alpha.20",
+  "version": "8.0.0-alpha.22",
   "type": "module",
   "description": "Datastore abstraction for core operations.",
   "keywords": [
@@ -27,14 +27,14 @@
     "directory": "module/model"
   },
   "dependencies": {
-    "@travetto/config": "^8.0.0-alpha.19",
-    "@travetto/di": "^8.0.0-alpha.18",
-    "@travetto/registry": "^8.0.0-alpha.18",
-    "@travetto/schema": "^8.0.0-alpha.19"
+    "@travetto/config": "^8.0.0-alpha.21",
+    "@travetto/di": "^8.0.0-alpha.19",
+    "@travetto/registry": "^8.0.0-alpha.19",
+    "@travetto/schema": "^8.0.0-alpha.21"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.25",
-    "@travetto/test": "^8.0.0-alpha.18"
+    "@travetto/cli": "^8.0.0-alpha.27",
+    "@travetto/test": "^8.0.0-alpha.20"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/registry/decorator.ts

@@ -89,6 +89,19 @@ export function Transient<T>() {
   };
 }
 
+/**
+ * Prevent a field from being persisted
+ * @augments `@travetto/schema:Field`
+ * @kind decorator
+ */
+export function TransientField() {
+  return function <K extends string, C extends Partial<Record<K, unknown>>>(instance: C, property: K): void {
+    ModelRegistryIndex.getForRegister(getClass(instance)).register({
+      transientFields: [property]
+    });
+  };
+}
+
 /**
  * Model class decorator for post-load behavior
  * @augments `@travetto/schema:Schema`

package/src/registry/registry-adapter.ts

@@ -10,6 +10,7 @@ function combineClasses(target: ModelConfig, sources: Partial<ModelConfig>[]): M
       indices: { ...(target.indices || {}), ...(source.indices || {}) },
       postLoad: [...(target.postLoad || []), ...(source.postLoad || [])],
       prePersist: [...(target.prePersist || []), ...(source.prePersist || [])],
+      transientFields: [...(target.transientFields || []), ...(source.transientFields || [])],
     });
   }
   if (target.store) {
@@ -33,7 +34,8 @@ export class ModelRegistryAdapter implements RegistryAdapter<ModelConfig> {
       autoCreate: 'development',
       store: this.#cls.name,
       postLoad: [],
-      prePersist: []
+      prePersist: [],
+      transientFields: []
     };
     combineClasses(config, data);
     return config;
@@ -50,6 +52,7 @@ export class ModelRegistryAdapter implements RegistryAdapter<ModelConfig> {
 
       config.postLoad = [...parent.postLoad ?? [], ...config.postLoad ?? []];
       config.prePersist = [...parent.prePersist ?? [], ...config.prePersist ?? []];
+      config.transientFields = [...parent.transientFields ?? [], ...config.transientFields ?? []];
     }
   }
 

package/src/registry/types.ts

@@ -60,4 +60,8 @@ export class ModelConfig<T extends ModelType = ModelType> {
    * Post-load handlers
    */
   postLoad?: DataHandler<unknown>[];
+  /**
+   * Fields to ignore during persistence
+   */
+  transientFields?: string[];
 }

package/src/util/crud.ts

@@ -1,4 +1,4 @@
-import { castTo, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
+import { castTo, castKey, type Class, Util, RuntimeError, hasFunction, BinaryUtil, type BinaryArray, JSONUtil } from '@travetto/runtime';
 import { DataUtil, SchemaRegistryIndex, SchemaValidator, type ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { ModelRegistryIndex } from '../registry/registry-index.ts';
@@ -111,6 +111,70 @@ export class ModelCrudUtil {
     return castTo(item);
   }
 
+  /**
+   * Recursively deletes or masks transient fields from an object based on its Model config.
+   * If transient fields are present, returns a copy with those fields set to undefined.
+   */
+  static cleanTransientFields<T>(cls: Class<T>, item: T): T {
+    if (!item || typeof item !== 'object') {
+      return item;
+    }
+    if (SchemaRegistryIndex.has(cls)) {
+      const schema = SchemaRegistryIndex.get(cls).get();
+      const transientFields = ModelRegistryIndex.has(cls) ? ModelRegistryIndex.getConfig(cls).transientFields : undefined;
+
+      const isCleanTarget = (key: string): boolean => {
+        return transientFields?.includes(key) ?? false;
+      };
+
+      const hasTargets = Object.keys(schema.fields).some(key => isCleanTarget(key));
+      
+      let res = item;
+      if (hasTargets) {
+        res = { ...item };
+        for (const key of Object.keys(schema.fields)) {
+          if (isCleanTarget(key)) {
+            res[castKey<T>(key)] = undefined!;
+          }
+        }
+      }
+
+      for (const [key, field] of Object.entries(schema.fields)) {
+        const fieldKey = castKey<typeof res>(key);
+        if (!isCleanTarget(key) && res[fieldKey] !== undefined && res[fieldKey] !== null) {
+          if (field.array && Array.isArray(res[fieldKey])) {
+            const arr = res[fieldKey] as any[];
+            let changed = false;
+            const newArr = arr.map(subItem => {
+              const cleaned = this.cleanTransientFields(field.type, subItem);
+              if (cleaned !== subItem) {
+                changed = true;
+              }
+              return cleaned;
+            });
+            if (changed) {
+              if (res === item) {
+                res = { ...item };
+              }
+              res[fieldKey] = newArr as any;
+            }
+          } else {
+            const val = res[fieldKey];
+            const cleaned = this.cleanTransientFields(field.type, val);
+            if (cleaned !== val) {
+              if (res === item) {
+                res = { ...item };
+              }
+              res[fieldKey] = cleaned;
+            }
+          }
+        }
+      }
+      return res;
+    }
+    return item;
+  }
+
   /**
    * Ensure subtype is not supported
    */
@@ -132,7 +196,7 @@ export class ModelCrudUtil {
         item = await handler(item) ?? item;
       }
     }
-    return item;
+    return this.cleanTransientFields(cls, item);
   }
 
   /**

package/support/test/basic.ts

@@ -1,10 +1,22 @@
 import assert from 'node:assert';
 
 import { Suite, Test } from '@travetto/test';
-import { type ModelCrudSupport, Model, NotFoundError } from '@travetto/model';
+import { type ModelCrudSupport, Model, NotFoundError, ModelCrudUtil, TransientField } from '@travetto/model';
 
 import { BaseModelSuite } from './base.ts';
 
+@Model('computed_person')
+class ComputedPerson {
+  id: string;
+  name: string;
+  @TransientField()
+  get nameUpper(): string {
+    return this.name.toUpperCase();
+  }
+  @TransientField()
+  ignoredField?: string;
+}
+
 @Model('basic_person')
 class Person {
   id: string;
@@ -59,4 +71,31 @@ export abstract class ModelBasicSuite extends BaseModelSuite<ModelCrudSupport> {
     assert(single !== undefined);
     assert(single.age === 25);
   }
+
+  @Test('Should not persist computed properties')
+  async testComputed() {
+    const service = await this.service;
+    const id = service.idSource.create();
+    await service.create(ComputedPerson, ComputedPerson.from({
+      id,
+      name: 'Bob',
+      ignoredField: 'secret'
+    }));
+
+    const retrieved = await service.get(ComputedPerson, id);
+    assert(retrieved.nameUpper === 'BOB');
+
+    // Verify it wasn't saved in the database holistically:
+    // When we fetch the document, the database driver retrieves a raw object and maps it.
+    // If the database stored 'nameUpper', trying to map it would set it on the retrieved instance.
+    // Since nameUpper is a getter-only property on the instance, we can verify that the persistence
+    // preparation (prePersist) recursively stripped the getter property from the stored object.
+    const instance = ComputedPerson.from({ id, name: 'Bob', ignoredField: 'secret' });
+    assert(Object.hasOwn(instance, 'nameUpper'));
+    assert(instance.ignoredField === 'secret');
+
+    const prepared = await ModelCrudUtil.prePersist(ComputedPerson, instance, 'all');
+    assert(prepared.nameUpper === undefined);
+    assert(prepared.ignoredField === undefined);
+  }
 }