@travetto/model-query 8.0.0-alpha.3 → 8.0.0-alpha.31

package/src/util/suggest.ts

@@ -1,5 +1,5 @@
 import { ModelRegistryIndex, type ModelType } from '@travetto/model';
-import { castTo, type Class, hasFunction } from '@travetto/runtime';
+import { type Class, castKey, castTo, hasFunction } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { PageableModelQuery, Query } from '../model/query.ts';
@@ -10,11 +10,10 @@ import type { ModelQuerySuggestSupport } from '../types/suggest.ts';
  * Tools for building suggestion queries
  */
 export class ModelQuerySuggestUtil {
-
   /**
    * Type guard for determining if service supports query suggest operations
    */
-  static isSupported = hasFunction<ModelQuerySuggestSupport>('suggest');
+  static isSupported = hasFunction<ModelQuerySuggestSupport>('suggestByQuery');
 
   /**
    * Build regex for suggesting
@@ -28,7 +27,15 @@ export class ModelQuerySuggestUtil {
    */
   static getSuggestQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: Query<T>): Query<T> {
     const limit = query?.limit ?? 10;
-    const clauses: WhereClauseRaw<ModelType>[] = prefix ? [{ [field]: { $regex: this.getSuggestRegex(prefix) } }] : [];
+    const clauses: WhereClauseRaw<ModelType>[] = [];
+    if (prefix) {
+      const parts = `${field}`.split('.');
+      let o: WhereClauseRaw<ModelType> = { [parts.at(-1)!]: { $regex: this.getSuggestRegex(prefix) } };
+      for (let i = parts.length - 2; i >= 0; i -= 1) {
+        o = { [parts[i]]: o };
+      }
+      clauses.push(o);
+    }
     const select: Query<T>['select'] = {
       ...query?.select
     };
@@ -36,9 +43,9 @@ export class ModelQuerySuggestUtil {
     const polymorphicConfig = SchemaRegistryIndex.getDiscriminatedConfig(cls);
     if (polymorphicConfig) {
       clauses.push({
-        [polymorphicConfig.discriminatedField]: polymorphicConfig.discriminatedBase ?
-          { $in: SchemaRegistryIndex.getDiscriminatedTypes(cls) } :
-          polymorphicConfig.discriminatedType
+        [polymorphicConfig.discriminatedField]: polymorphicConfig.discriminatedBase
+          ? { $in: SchemaRegistryIndex.getDiscriminatedTypes(cls) }
+          : polymorphicConfig.discriminatedType
       });
       if (query?.select) {
         Object.assign(select, { [polymorphicConfig.discriminatedField]: true });
@@ -75,8 +82,13 @@ export class ModelQuerySuggestUtil {
     const pattern = this.getSuggestRegex(prefix);
 
     const out: ([string, U] | readonly [string, U])[] = [];
+    const parts = `${field}`.split('.');
+
     for (const result of results) {
-      const resultValue = result[field];
+      let resultValue = result[castKey<T>(parts[0])];
+      for (let i = 1; i < parts.length && resultValue !== undefined && resultValue !== null; i += 1) {
+        resultValue = resultValue[castKey(parts[i])];
+      }
       if (Array.isArray(resultValue)) {
         out.push(...resultValue.filter(item => pattern.test(item)).map((item: string) => [item, transform(item, result)] as const));
       } else if (typeof resultValue === 'string') {
@@ -85,7 +97,7 @@ export class ModelQuerySuggestUtil {
     }
     return out
       .toSorted((a, b) => a[0].localeCompare(b[0]))
-      .map((a) => a[1])
+      .map(a => a[1])
       .filter((result, i, arr) => result !== arr[i - 1])
       .slice(0, limit ?? 10);
   }
@@ -93,7 +105,12 @@ export class ModelQuerySuggestUtil {
   /**
    * Build suggestion query
    */
-  static getSuggestFieldQuery<T extends ModelType>(cls: Class<T>, field: ValidStringFields<T>, prefix?: string, query?: PageableModelQuery<T>): Query<T> {
+  static getSuggestFieldQuery<T extends ModelType>(
+    cls: Class<T>,
+    field: ValidStringFields<T>,
+    prefix?: string,
+    query?: PageableModelQuery<T>
+  ): Query<T> {
     return this.getSuggestQuery<T>(cls, castTo(field), prefix, query);
   }
-}
+}

package/src/verifier.ts

@@ -1,10 +1,10 @@
 /* eslint @typescript-eslint/no-unused-vars: ["error", { "args": "none"} ] */
-import { DataUtil, ValidationResultError, type ValidationError, SchemaRegistryIndex } from '@travetto/schema';
-import { JSONUtil, type Class } from '@travetto/runtime';
 
-import type { ModelQuery, Query, PageableModelQuery } from './model/query.ts';
+import { type Class, JSONUtil } from '@travetto/runtime';
+import { DataUtil, SchemaRegistryIndex, type ValidationError, ValidationResultError } from '@travetto/schema';
 
 import { TypeUtil } from './internal/types.ts';
+import type { ModelQuery, PageableModelQuery, Query } from './model/query.ts';
 
 type SimpleType = keyof typeof TypeUtil.OPERATORS;
 
@@ -28,24 +28,19 @@ const WHERE = 'where';
 const SORT = 'sort';
 // const GROUP_BY = 'groupBy';
 
-const MULTIPLE_KEYS_ALLOWED = new Set([
-  '$maxDistance', '$gt', '$gte',
-  '$minDistance', '$lt', '$lte',
-  '$near'
-]);
+const MULTIPLE_KEYS_ALLOWED = new Set(['$maxDistance', '$gt', '$gte', '$minDistance', '$lt', '$lte', '$near']);
 
 /**
  * Query verification service.  Used to verify the query is valid before running.
  */
 export class QueryVerifier {
-
   /**
    * Internal mapping for various clauses
    */
   static #mapping = [
     [SELECT, 'processSelectClause'] as const,
     [WHERE, 'processWhereClause'] as const,
-    [SORT, 'processSortClause'] as const,
+    [SORT, 'processSortClause'] as const
   ];
 
   /**
@@ -59,19 +54,18 @@ export class QueryVerifier {
       return;
     }
 
-    if (handler.preMember && handler.preMember(state, clause)) {
+    if (handler.preMember?.(state, clause)) {
       return;
     }
 
     for (const [key, value] of Object.entries(clause)) {
-
       // Validate value is correct, and key is valid
       if (value === undefined || value === null) {
         // state.log(`${key} cannot be undefined or null`);
         continue;
       }
 
-      if (handler.preMember && handler.preMember(state, value)) {
+      if (handler.preMember?.(state, value)) {
         continue;
       }
 
@@ -91,7 +85,7 @@ export class QueryVerifier {
         // Otherwise recurse
         const subCls = field.type;
         const subValue = value;
-        if (handler.onComplexType && handler.onComplexType(state, subCls, subValue, field.array ?? false)) {
+        if (handler.onComplexType?.(state, subCls, subValue, field.array ?? false)) {
           continue;
         }
         this.processGenericClause(state.extend(key), subCls, subValue, handler);
@@ -109,7 +103,13 @@ export class QueryVerifier {
   /**
    * Check operator clause
    */
-  static checkOperatorClause(state: State, declaredType: SimpleType, value: unknown, allowed: Record<string, Set<string>>, isArray: boolean): void {
+  static checkOperatorClause(
+    state: State,
+    declaredType: SimpleType,
+    value: unknown,
+    allowed: Record<string, Set<string>>,
+    isArray: boolean
+  ): void {
     if (isArray && Array.isArray(value)) {
       // Handle array literal
       for (const item of value) {
@@ -128,11 +128,7 @@ export class QueryVerifier {
     } else {
       const keys = Object.keys(value).toSorted();
 
-      if (keys.length !== 1 && !(
-        keys.length >= 2 &&
-        MULTIPLE_KEYS_ALLOWED.has(keys[0]) ||
-        MULTIPLE_KEYS_ALLOWED.has(keys[1])
-      )) {
+      if (keys.length !== 1 && !((keys.length >= 2 && MULTIPLE_KEYS_ALLOWED.has(keys[0])) || MULTIPLE_KEYS_ALLOWED.has(keys[1]))) {
         state.log('One and only one operation may be specified in an operator clause');
         return;
       }
@@ -172,7 +168,7 @@ export class QueryVerifier {
    * Process where clause
    */
   static processWhereClause<T>(st: State, cls: Class<T>, passed: object): void {
-    return this.processGenericClause(st, cls, passed, {
+    this.processGenericClause(st, cls, passed, {
       preMember: (state: State, value: Record<string, unknown>) => {
         const keys = Object.keys(value);
         const firstKey = keys[0];
@@ -221,7 +217,7 @@ export class QueryVerifier {
    * Handle sort clause
    */
   static processSortClause<T>(st: State, cls: Class<T>, passed: object): void {
-    return this.processGenericClause(st, cls, passed, {
+    this.processGenericClause(st, cls, passed, {
       onSimpleType: (state, type, value) => {
         if (value === 1 || value === -1 || typeof value === 'boolean') {
           return;
@@ -235,7 +231,7 @@ export class QueryVerifier {
    * Handle select clause
    */
   static processSelectClause<T>(st: State, cls: Class<T>, passed: object): void {
-    return this.processGenericClause(st, cls, passed, {
+    this.processGenericClause(st, cls, passed, {
       onSimpleType: (state, type, value) => {
         const actual = TypeUtil.getActualType(value);
         if (actual === 'number' || actual === 'boolean') {
@@ -244,7 +240,7 @@ export class QueryVerifier {
           }
           state.log('Only true, false 0, and 1 are allowed for including/excluding fields');
         } else {
-        /* if (actual === 'string') {
+          /* if (actual === 'string') {
           if (!/[A-Za-z_$0-9]/.test(value)) {
             state.log(`Only A-Z, a-z, 0-9, '$' and '_' are allowed in aliases for selecting fields`);
             return;
@@ -258,7 +254,8 @@ export class QueryVerifier {
             // or { alias: string, calc?: string }
             // console.log('Yay');
           }
-        */}
+        */
+        }
         state.log('Only true, false, 0, and 1 are allowed for selecting fields');
       }
     });
@@ -293,10 +290,7 @@ export class QueryVerifier {
         continue;
       }
 
-      if (!(key in query)
-        || query[key] === undefined
-        || query[key] === null
-      ) {
+      if (!(key in query) || query[key] === undefined || query[key] === null) {
         continue;
       }
 
@@ -316,4 +310,4 @@ export class QueryVerifier {
       throw new ValidationResultError(errors);
     }
   }
-}
+}

package/support/doc.support.tsx

@@ -1,10 +1,10 @@
 /** @jsxImportSource @travetto/doc/support */
-import { d, type DocJSXElementByFn, type DocJSXElement, DocFileUtil } from '@travetto/doc';
-import { Runtime, toConcrete } from '@travetto/runtime';
+import { DocFileUtil, type DocJSXElement, type DocJSXElementByFn, d } from '@travetto/doc';
+import { castKey, Runtime, toConcrete } from '@travetto/runtime';
 
 import type { ModelQueryCrudSupport } from '../src/types/crud.ts';
+import type { ModelQueryFacetSupport } from '../src/types/facet.ts';
 import type { ModelQuerySupport } from '../src/types/query.ts';
-import type { ModelQueryFacetSupport, } from '../src/types/facet.ts';
 import type { ModelQuerySuggestSupport } from '../src/types/suggest.ts';
 
 const toLink = (title: string, target: Function): DocJSXElementByFn<'CodeLink'> =>
@@ -14,7 +14,7 @@ export const Links = {
   QueryCrud: toLink('Query Crud', toConcrete<ModelQueryCrudSupport>()),
   QueryFacet: toLink('Facet', toConcrete<ModelQueryFacetSupport>()),
   QuerySuggest: toLink('Suggest', toConcrete<ModelQuerySuggestSupport>()),
-  Query: toLink('Query', toConcrete<ModelQuerySupport>()),
+  Query: toLink('Query', toConcrete<ModelQuerySupport>())
 };
 
 export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
@@ -24,10 +24,9 @@ export const ModelQueryTypes = (fn: Function): DocJSXElement[] => {
   for (const [, key] of content.matchAll(/Model(Query(Suggest|Facet|Crud)?)Support/g)) {
     if (!seen.has(key) && key in Links) {
       seen.add(key);
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      const link = Links[key as keyof typeof Links];
+      const link = Links[castKey(key)];
       found.push(link);
     }
   }
   return found.map(type => <li>{type}</li>);
-};
+};

package/support/test/crud.ts

@@ -1,15 +1,37 @@
 import assert from 'node:assert';
 
+import { Model, type ModelCrudSupport, NotFoundError, UniqueError } from '@travetto/model';
+import { castTo } from '@travetto/runtime';
 import { Suite, Test } from '@travetto/test';
-import { type ModelCrudSupport, NotFoundError } from '@travetto/model';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { Address, Person, Todo, BigIntModel } from './model.ts';
+import { QueryIndex } from '../../__index__.ts';
 import type { ModelQueryCrudSupport } from '../../src/types/crud.ts';
+import { Address, BigIntModel, Person, Todo } from './model.ts';
+
+@Model()
+@QueryIndex({
+  name: 'uniqueUser2',
+  fields: [{ name: true }],
+  unique: true
+})
+class UniqueUser2 {
+  id: string;
+  name: string;
+}
 
 @Suite()
 export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudSupport & ModelCrudSupport> {
+  supportsUniqueIndexes = true;
+
+  @Test({ skip: self => !castTo<ModelQueryCrudSuite>(self).supportsUniqueIndexes })
+  async testUnique() {
+    const svc = await this.service;
+    await svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' }));
+    await assert.rejects(() => svc.create(UniqueUser2, UniqueUser2.from({ name: 'bob' })), UniqueError);
+  }
+
   @Test()
   async testUpdateOneWithQuery() {
     const svc = await this.service;
@@ -19,31 +41,44 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(todo1.id);
     assert(todo1.version === 0);
 
-    const todo1v2 = await svc.updateByQuery(Todo, Todo.from({
-      id: todo1.id,
-      text: `${todo1.text}!!`,
-      version: todo1.version + 1
-    }), { where: { id: todo1.id, version: todo1.version } },);
+    const todo1v2 = await svc.updateByQuery(
+      Todo,
+      Todo.from({
+        id: todo1.id,
+        text: `${todo1.text}!!`,
+        version: todo1.version + 1
+      }),
+      { where: { id: todo1.id, version: todo1.version } }
+    );
 
     assert(todo1v2.id === todo1.id);
     assert(todo1v2.version > todo1.version);
 
     await assert.rejects(
-      () => svc.updateByQuery(Todo, Todo.from({
-        id: todo1.id,
-        text: `${todo1.text}!!`,
-        version: todo1.version + 1
-      }), { where: { id: todo1.id, version: todo1.version } }),
+      () =>
+        svc.updateByQuery(
+          Todo,
+          Todo.from({
+            id: todo1.id,
+            text: `${todo1.text}!!`,
+            version: todo1.version + 1
+          }),
+          { where: { id: todo1.id, version: todo1.version } }
+        ),
       NotFoundError
     );
 
     const todo2 = await svc.create(Todo, Todo.from({ text: 'bob2' }));
 
-    const result = await svc.updateByQuery(Todo, Todo.from({
-      id: todo2.id,
-      text: `${todo1.text}!!`,
-      version: todo1.version + 1
-    }), { where: { id: todo2.id, text: 'bob2' } });
+    const result = await svc.updateByQuery(
+      Todo,
+      Todo.from({
+        id: todo2.id,
+        text: `${todo1.text}!!`,
+        version: todo1.version + 1
+      }),
+      { where: { id: todo2.id, text: 'bob2' } }
+    );
 
     assert(result.id === todo2.id);
   }
@@ -91,15 +126,20 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
   async testDeleteByQuery() {
     const svc = await this.service;
 
-    const count = await this.saveAll(Person, [1, 2, 3, 4, 5].map(d => Person.from({
-      age: d,
-      gender: 'm',
-      name: `Test ${d}`,
-      address: Address.from({
-        street1: 'street1',
-        street2: 'street2'
-      })
-    })));
+    const count = await this.saveAll(
+      Person,
+      [1, 2, 3, 4, 5].map(d =>
+        Person.from({
+          age: d,
+          gender: 'm',
+          name: `Test ${d}`,
+          address: Address.from({
+            street1: 'street1',
+            street2: 'street2'
+          })
+        })
+      )
+    );
 
     assert(count === 5);
 
@@ -107,33 +147,37 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(c === 2);
 
-    assert(await svc.queryCount(Person, {}) === 3);
+    assert((await svc.queryCount(Person, {})) === 3);
 
     const c2 = await svc.deleteByQuery(Person, { where: { age: { $lte: 3 } } });
 
     assert(c2 === 3);
 
-    assert(await svc.queryCount(Person, {}) === 0);
-
+    assert((await svc.queryCount(Person, {})) === 0);
   }
 
   @Test()
   async testUpdateByQuery() {
     const svc = await this.service;
 
-    const count = await this.saveAll(Person, [1, 2, 3, 4, 5].map(d => Person.from({
-      age: d,
-      gender: 'm',
-      name: `Test ${d}`,
-      address: Address.from({
-        street1: 'street1',
-        street2: 'street2'
-      })
-    })));
+    const count = await this.saveAll(
+      Person,
+      [1, 2, 3, 4, 5].map(d =>
+        Person.from({
+          age: d,
+          gender: 'm',
+          name: `Test ${d}`,
+          address: Address.from({
+            street1: 'street1',
+            street2: 'street2'
+          })
+        })
+      )
+    );
 
     assert(count === 5);
 
-    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 5);
+    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 5);
 
     const c = await svc.updatePartialByQuery(Person, { where: { age: { $gt: 3 } } }, { gender: 'f' });
 
@@ -141,15 +185,14 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
 
     assert(c === 2);
 
-    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 3);
+    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 3);
 
     const c2 = await svc.updatePartialByQuery(Person, { where: { gender: 'm' } }, { gender: 'f' });
 
     assert(c2 === 3);
 
-    assert(await svc.queryCount(Person, { where: { gender: 'f' } }) === 5);
-    assert(await svc.queryCount(Person, { where: { gender: 'm' } }) === 0);
-
+    assert((await svc.queryCount(Person, { where: { gender: 'f' } })) === 5);
+    assert((await svc.queryCount(Person, { where: { gender: 'm' } })) === 0);
   }
 
   @Test()
@@ -162,7 +205,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
       BigIntModel.from({ largeNumber: 200n, optionalBigInt: 2000n }),
       BigIntModel.from({ largeNumber: 300n }),
       BigIntModel.from({ largeNumber: 9007199254740991n, optionalBigInt: 1234567890123456789n }),
-      BigIntModel.from({ largeNumber: 18014398509481982n }),
+      BigIntModel.from({ largeNumber: 18014398509481982n })
     ]);
 
     assert(count === 5);
@@ -205,17 +248,13 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     const count = await this.saveAll(BigIntModel, [
       BigIntModel.from({ largeNumber: 100n, optionalBigInt: 1000n }),
       BigIntModel.from({ largeNumber: 200n, optionalBigInt: 2000n }),
-      BigIntModel.from({ largeNumber: 300n }),
+      BigIntModel.from({ largeNumber: 300n })
     ]);
 
     assert(count === 3);
 
     // Update records with bigint condition
-    const updated = await svc.updatePartialByQuery(
-      BigIntModel,
-      { where: { largeNumber: { $lte: 200n } } },
-      { optionalBigInt: 5000n }
-    );
+    const updated = await svc.updatePartialByQuery(BigIntModel, { where: { largeNumber: { $lte: 200n } } }, { optionalBigInt: 5000n });
 
     assert(updated === 2);
 
@@ -235,7 +274,7 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
       BigIntModel.from({ largeNumber: 200n }),
       BigIntModel.from({ largeNumber: 300n }),
       BigIntModel.from({ largeNumber: 400n }),
-      BigIntModel.from({ largeNumber: 500n }),
+      BigIntModel.from({ largeNumber: 500n })
     ]);
 
     assert(count === 5);
@@ -253,4 +292,3 @@ export abstract class ModelQueryCrudSuite extends BaseModelSuite<ModelQueryCrudS
     assert(all.every(x => x.largeNumber <= 300n));
   }
 }
-

package/support/test/facet.ts

@@ -5,8 +5,8 @@ import { Suite, Test } from '@travetto/test';
 
 import { BaseModelSuite } from '@travetto/model/support/test/base.ts';
 
-import { Person } from './model.ts';
 import type { ModelQueryFacetSupport } from '../../src/types/facet.ts';
+import { Person } from './model.ts';
 
 const pick = <T>(arr: T[] | readonly T[]): T => arr[Math.trunc(Math.random() * arr.length)]!;
 
@@ -17,31 +17,39 @@ const AGES = new Array(100).fill(0).map((x, i) => i + 10);
 
 @Suite()
 export abstract class ModelQueryFacetSuite extends BaseModelSuite<ModelQueryFacetSupport & ModelCrudSupport> {
-
   @Test('verify aggregations')
   async testFacet() {
-    const people = ' '.repeat(50)
+    const people = ' '
+      .repeat(50)
       .split('')
-      .map(() => Person.from({
-        age: pick(AGES),
-        gender: pick(GENDERS),
-        name: `${pick(FNAME)} ${pick(LNAME)}`,
-        address: {
-          street1: `${pick(AGES)} ${pick(LNAME)} Road`
-        }
-      }));
+      .map(() =>
+        Person.from({
+          age: pick(AGES),
+          gender: pick(GENDERS),
+          name: `${pick(FNAME)} ${pick(LNAME)}`,
+          address: {
+            street1: `${pick(AGES)} ${pick(LNAME)} Road`
+          }
+        })
+      );
 
     const svc = await this.service;
     const saved = await this.saveAll(Person, people);
 
     assert(saved === 50);
 
-    const results = await svc.facet(Person, 'gender');
+    const results = await svc.facetByQuery(Person, 'gender');
 
     assert(results.length === 2);
     assert(results[0].count >= results[1].count);
 
-    const genders = people.reduce((acc, p) => { (acc[p.gender] += 1); return acc; }, { m: 0, f: 0 });
+    const genders = people.reduce(
+      (acc, p) => {
+        acc[p.gender] += 1;
+        return acc;
+      },
+      { m: 0, f: 0 }
+    );
 
     assert(results.find(x => x.key === 'm')!.count === genders.m);
     assert(results.find(x => x.key === 'f')!.count === genders.f);
@@ -51,7 +59,7 @@ export abstract class ModelQueryFacetSuite extends BaseModelSuite<ModelQueryFace
       names[el.name!] = (names[el.name!] || 0) + 1;
     }
 
-    const nameFacet = await svc.facet(Person, 'name');
+    const nameFacet = await svc.facetByQuery(Person, 'name');
     assert(Object.keys(names).length === nameFacet.length);
   }
-}
+}

package/support/test/model.ts

@@ -1,5 +1,5 @@
-import { Precision, Schema, Text, type Point } from '@travetto/schema';
 import { Model, type ModelType } from '@travetto/model';
+import { type Point, Precision, Schema, Text } from '@travetto/schema';
 
 @Schema()
 export class Address {
@@ -98,4 +98,36 @@ export class BigIntModel {
   id: string;
   largeNumber: bigint;
   optionalBigInt?: bigint;
-}
+}
+
+@Schema()
+export class Child {
+  name: string;
+}
+
+@Schema()
+export class Family {
+  children?: Child[];
+}
+
+@Model()
+export class PersonFamily implements ModelType {
+  id: string;
+  family?: Family;
+}
+
+@Schema()
+export class RecipeIngredient {
+  name: string;
+}
+
+@Schema()
+export class RecipeSection {
+  ingredients: RecipeIngredient[] = [];
+}
+
+@Model()
+export class Recipe implements ModelType {
+  id: string;
+  sections: RecipeSection[] = [];
+}