Support nested objects and arrays in the model definition

package.json

@@ -37,13 +37,13 @@
     "typescript": "4.3.5"
   },
   "dependencies": {
-    "@types/lodash.get": "^4.4.6",
+    "@types/lodash": "^4.14.172",
     "@types/md5": "^2.3.0",
     "@types/pluralize": "^0.0.29",
     "@types/uuid": "^8.3.0",
     "date-fns": "^2.21.1",
     "graphql": "^15.5.0",
-    "lodash.get": "^4.4.2",
+    "lodash": "^4.17.21",
     "md5": "^2.3.0",
     "pluralize": "^8.0.0",
     "strict-event-emitter": "^0.2.0",

src/glossary.ts

@@ -7,7 +7,7 @@ import {
 } from './query/queryTypes'
 
 export type PrimaryKeyType = string | number
-export type BaseTypes = string | number | boolean | Date
+export type PrimitiveValueType = string | number | boolean | Date
 export type KeyType = string | number | symbol
 
 export enum InternalEntityProperty {
@@ -17,7 +17,7 @@ export enum InternalEntityProperty {
 }
 
 export interface PrimaryKeyDeclaration<
-  ValueType extends PrimaryKeyType = string
+  ValueType extends PrimaryKeyType = string,
 > {
   isPrimaryKey: boolean
   getValue(): ValueType
@@ -34,7 +34,7 @@ export enum RelationKind {
  */
 export interface RelationDefinition<
   Kind extends RelationKind,
-  ModelName extends KeyType
+  ModelName extends KeyType,
 > {
   kind: Kind
   unique: boolean
@@ -52,11 +52,10 @@ export interface Relation {
  * Minimal representation of an entity to look it up
  * in the database and resolve upon reference.
  */
-export type RelationRef<
-  ModelName extends string
-> = InternalEntityProperties<ModelName> & {
-  [InternalEntityProperty.nodeId]: PrimaryKeyType
-}
+export type RelationRef<ModelName extends string> =
+  InternalEntityProperties<ModelName> & {
+    [InternalEntityProperty.nodeId]: PrimaryKeyType
+  }
 
 export interface RelationOptions {
   unique: boolean
@@ -74,7 +73,8 @@ export type ManyOf<ModelName extends KeyType> = RelationDefinition<
 
 export type ModelDefinition = Record<
   string,
-  (() => BaseTypes) | OneOf<any> | ManyOf<any> | PrimaryKeyDeclaration
+  PrimaryKeyDeclaration | OneOf<any> | ManyOf<any> | (() => PrimitiveValueType)
+  // | Record<string, unknown>
 >
 
 export type FactoryAPI<Dictionary extends Record<string, any>> = {
@@ -88,20 +88,20 @@ export interface InternalEntityProperties<ModelName extends KeyType> {
 
 export type Entity<
   Dictionary extends ModelDictionary,
-  ModelName extends keyof Dictionary
+  ModelName extends keyof Dictionary,
 > = Value<Dictionary[ModelName], Dictionary>
 
 export type InternalEntity<
   Dictionary extends ModelDictionary,
-  ModelName extends keyof Dictionary
+  ModelName extends keyof Dictionary,
 > = InternalEntityProperties<ModelName> & Entity<Dictionary, ModelName>
 
 export type ModelDictionary = Limit<Record<string, Record<string, any>>>
 
 export type Limit<T extends Record<string, any>> = {
   [RK in keyof T]: {
     [SK in keyof T[RK]]: T[RK][SK] extends
-      | (() => BaseTypes)
+      | (() => PrimitiveValueType)
       | PrimaryKeyDeclaration
       | OneOf<keyof T>
       | ManyOf<keyof T>
@@ -115,24 +115,22 @@ export type Limit<T extends Record<string, any>> = {
 
 export type RequireExactlyOne<
   ObjectType,
-  KeysType extends keyof ObjectType = keyof ObjectType
+  KeysType extends keyof ObjectType = keyof ObjectType,
 > = {
   [Key in KeysType]: Required<Pick<ObjectType, Key>> &
     Partial<Record<Exclude<KeysType, Key>, never>>
 }[KeysType] &
   Pick<ObjectType, Exclude<keyof ObjectType, KeysType>>
 
-export type DeepRequireExactlyOne<ObjectType> = RequireExactlyOne<
-  {
-    [K in keyof ObjectType]: ObjectType[K] extends Record<any, any>
-      ? RequireExactlyOne<ObjectType[K]>
-      : ObjectType[K]
-  }
->
+export type DeepRequireExactlyOne<ObjectType> = RequireExactlyOne<{
+  [K in keyof ObjectType]: ObjectType[K] extends Record<any, any>
+    ? RequireExactlyOne<ObjectType[K]>
+    : ObjectType[K]
+}>
 
 export interface ModelAPI<
   Dictionary extends ModelDictionary,
-  ModelName extends keyof Dictionary
+  ModelName extends keyof Dictionary,
 > {
   /**
    * Create a single entity for the model.
@@ -206,7 +204,7 @@ export interface ModelAPI<
 
 export type UpdateManyValue<
   T extends Record<string, any>,
-  Parent extends Record<string, any>
+  Parent extends Record<string, any>,
 > =
   | Value<T, Parent>
   | {
@@ -223,7 +221,7 @@ export type UpdateManyValue<
 
 export type Value<
   T extends Record<string, any>,
-  Parent extends Record<string, any>
+  Parent extends Record<string, any>,
 > = {
   [K in keyof T]: T[K] extends OneOf<any>
     ? Entity<Parent, T[K]['modelName']>

src/model/createModel.ts

@@ -1,4 +1,7 @@
 import { debug } from 'debug'
+import get from 'lodash/get'
+import set from 'lodash/set'
+import isFunction from 'lodash/isFunction'
 import { Database } from '../db/Database'
 import {
   InternalEntity,
@@ -15,7 +18,7 @@ const log = debug('createModel')
 
 export function createModel<
   Dictionary extends ModelDictionary,
-  ModelName extends string
+  ModelName extends string,
 >(
   modelName: ModelName,
   definition: ModelDefinition,
@@ -33,52 +36,58 @@ export function createModel<
     initialValues,
   )
 
+  // Internal properties that allow identifying this model
+  // when referenced in other models (i.e. via relatioships).
   const internalProperties: InternalEntityProperties<ModelName> = {
     [InternalEntityProperty.type]: modelName,
     [InternalEntityProperty.primaryKey]: primaryKey,
   }
 
-  const resolvedProperties = properties.reduce<Record<string, any>>(
-    (entity, property) => {
-      const exactValue = initialValues[property]
-      const propertyDefinition = definition[property]
-
-      log(
-        `property definition for "${modelName}.${property}"`,
-        propertyDefinition,
-      )
+  const publicProperties = properties.reduce<Record<string, unknown>>(
+    (properties, propertyName) => {
+      const value = get(initialValues, propertyName)
+      const propertyDefinition = get(definition, propertyName)
 
       // Ignore relational properties at this stage.
       if ('kind' in propertyDefinition) {
-        return entity
+        return properties
       }
 
       if ('isPrimaryKey' in propertyDefinition) {
-        entity[property] = exactValue || propertyDefinition.getValue()
-        return entity
+        set(properties, propertyName, value || propertyDefinition.getValue())
+        return properties
       }
 
       if (
-        typeof exactValue === 'string' ||
-        typeof exactValue === 'number' ||
-        typeof exactValue === 'boolean' ||
-        exactValue?.constructor.name === 'Date'
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean' ||
+        value?.constructor.name === 'Date' ||
+        Array.isArray(value)
       ) {
-        log(`"${modelName}.${property}" has a plain initial value:`, exactValue)
-        entity[property] = exactValue
-        return entity
+        log(
+          '"%s" has a plain initial value:',
+          `${modelName}.${propertyName}`,
+          value,
+        )
+        set(properties, propertyName, value)
+        return properties
+      }
+
+      if (isFunction(propertyDefinition)) {
+        set(properties, propertyName, propertyDefinition())
+        return properties
       }
 
-      entity[property] = propertyDefinition()
-      return entity
+      return properties
     },
     {},
   )
 
-  const entity = Object.assign({}, resolvedProperties, internalProperties)
+  const entity = Object.assign({}, publicProperties, internalProperties)
   defineRelationalProperties(entity, initialValues, relations, db)
 
-  log(`created "${modelName}" entity`, entity)
+  log('created "%s" entity', modelName, entity)
 
   return entity
 }

src/model/defineRelationalProperties.ts

@@ -1,4 +1,7 @@
 import { debug } from 'debug'
+import get from 'lodash/get'
+import set from 'lodash/set'
+import { isObject } from '../utils/isObject'
 import { Database } from '../db/Database'
 import {
   Entity,
@@ -37,10 +40,12 @@ export function defineRelationalProperties(
         relation,
       )
 
-      if (!(property in initialValues)) return properties
+      if (!get(initialValues, property)) return properties
 
       // Take the relational entity reference from the initial values.
-      const entityRefs: Entity<any, any>[] = [].concat(initialValues[property])
+      const entityRefs: Entity<any, any>[] = [].concat(
+        get(initialValues, property),
+      )
 
       if (relation.unique) {
         log(`verifying that the "${property}" relation is unique...`)
@@ -83,7 +88,7 @@ export function defineRelationalProperties(
         }
       }
 
-      properties[property] = {
+      set(properties, property, {
         enumerable: true,
         get() {
           log(`get "${property}"`, relation)
@@ -107,17 +112,44 @@ export function defineRelationalProperties(
             },
             [],
           )
+
           log(`resolved "${relation.kind}" "${property}" to`, refValue)
 
           return relation.kind === RelationKind.OneOf
             ? first(refValue)!
             : refValue
         },
-      }
-
+      })
       return properties
     },
     {},
   )
-  Object.defineProperties(entity, properties)
+  defineNestedProperties(entity, properties, '')
+}
+
+function defineNestedProperties(
+  entity: InternalEntity<any, any>,
+  properties: any,
+  path: string,
+) {
+  for (let key in properties) {
+    const value = properties[key]
+    const nestedPath = path ? `${path}.${key}` : key
+
+    if (isRelationalProperty(value)) {
+      const nestedPathArray = nestedPath.split('.')
+      nestedPathArray.reduce((acc, curr, i) => {
+        if (i === nestedPathArray.length - 1) {
+          Object.defineProperty(acc, curr, value)
+        }
+        return acc[curr]
+      }, entity)
+    } else if (isObject(value)) {
+      defineNestedProperties(entity, value, nestedPath)
+    }
+  }
+}
+
+function isRelationalProperty(val: any) {
+  return val?.enumerable && typeof val?.get === 'function'
 }