Pass instance to derived default value

src/attributes/decorator.js

@@ -1,9 +1,9 @@
 const Schema = require('../schema');
 const Serialization = require('../serialization');
 const Validation = require('../validation');
+const Initialization = require('../initialization');
 const Errors = require('../errors');
 const { SCHEMA } = require('../symbols');
-const Initializer = require('./initializer');
 const {
   attributeDescriptorFor,
   attributesDescriptorFor
@@ -22,7 +22,7 @@ function attributesDecorator(schema, schemaOptions = {}) {
         const instance = Reflect.construct(target, constructorArgs, newTarget);
         const passedAttributes = Object.assign({}, constructorArgs[0]);
 
-        Initializer.initialize(passedAttributes, schema, instance);
+        Initialization.initialize(schema, passedAttributes, instance);
 
         return instance;
       }

src/initialization/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+  forSchema: require('./initialization'),
+  initialize: require('./initialize')
+};

src/initialization/initialization.js

@@ -0,0 +1,28 @@
+const { ATTRIBUTES } = require('../symbols');
+const initializationOrderFor = require('./initializationOrder');
+
+function initializedValue(attrPassedValue, attrInitializer, attrDescriptor, instance) {
+  if(attrPassedValue !== undefined) {
+    return attrPassedValue;
+  }
+
+  return attrInitializer(attrDescriptor, instance);
+}
+
+module.exports = function forSchema(schema) {
+  const initializationOrder = initializationOrderFor(schema);
+
+  return {
+    initialize(attributes, instance) {
+      instance[ATTRIBUTES] = Object.create(null);
+
+      for(let i = 0; i < initializationOrder.length; i++) {
+        const [ attrName, attrInitializer ] = initializationOrder[i];
+        const attrDescriptor = schema[attrName];
+        const attrPassedValue = attributes[attrName];
+
+        instance[attrName] = initializedValue(attrPassedValue, attrInitializer, attrDescriptor, instance);
+      }
+    }
+  };
+};

src/initialization/initializationOrder.js

@@ -0,0 +1,30 @@
+const { isFunction } = require('lodash');
+
+function isStaticInitialization(attrDescriptor) {
+  return !isFunction(attrDescriptor.default);
+}
+
+function staticInitialization(attrDescriptor) {
+  return attrDescriptor.default;
+}
+
+function derivedInitialization(attrDescriptor, instance) {
+  return attrDescriptor.default(instance);
+}
+
+module.exports = function initializationOrderFor(schema) {
+  const staticInitializations = [];
+  const derivedInitializations = [];
+
+  for(let attrName in schema) {
+    const attributeDescriptor = schema[attrName];
+
+    if(isStaticInitialization(attributeDescriptor)) {
+      staticInitializations.push([attrName, staticInitialization]);
+    } else {
+      derivedInitializations.push([attrName, derivedInitialization]);
+    }
+  }
+
+  return [...staticInitializations, ...derivedInitializations];
+};

src/initialization/initialize.js

@@ -0,0 +1,5 @@
+const { INITIALIZE } = require('../symbols');
+
+module.exports = function initialize(schema, attributes, instance) {
+  schema[INITIALIZE].initialize(attributes, instance);
+};

src/schema/normalization.js

@@ -1,6 +1,7 @@
 const Validation = require('../validation');
+const Initialization = require('../initialization');
 const TypeDescriptor = require('../typeDescriptor');
-const { VALIDATE } = require('../symbols');
+const { VALIDATE, INITIALIZE } = require('../symbols');
 
 module.exports = function normalizeSchema(rawSchema, schemaOptions) {
   const schema = Object.create(null);
@@ -15,5 +16,11 @@ module.exports = function normalizeSchema(rawSchema, schemaOptions) {
     value: schemaValidation
   });
 
+  const initialization = Initialization.forSchema(schema);
+
+  Object.defineProperty(schema, INITIALIZE, {
+    value: initialization
+  });
+
   return schema;
 };

src/symbols.js

@@ -1,5 +1,6 @@
 module.exports = {
   SCHEMA: Symbol('schema'),
   ATTRIBUTES: Symbol('attributes'),
-  VALIDATE: Symbol('validate')
+  VALIDATE: Symbol('validate'),
+  INITIALIZE: Symbol('initialize')
 };