How to use the datx-utils.assignComputed function in datx-utils

type: FieldType = FieldType.DATA,
) {
  const fields = getModelMetaKey(obj, 'fields') as Array;

  if (type === FieldType.ID && key in obj) {
    storage.setModelDataKey(obj, key, undefined);
  }

  // Initialize the observable field to the default value
  storage.setModelDataKey(obj, key, defValue);
  updateAction(obj, key, defValue);
  if (fields.indexOf(key) === -1) {
    fields.push(key);
  }

  assignComputed(obj, key,
    () => getField(obj, key),
    (value) => {
      updateField(obj, key, value, type);
    },
  );
}

export function initModelRef(obj: PureModel, key: string, options: IReferenceOptions, initialVal: TRefValue) {
  const refs = getModelMetaKey(obj, 'refs');

  // Initialize the observable field to the given value
  refs[key] = options;

  const isArray = options.type === ReferenceType.TO_MANY;
  storage.setModelDataKey(obj, key, isArray ? [] : undefined);
  updateAction(obj, key, isArray ? [] : undefined);

  assignComputed(obj, key,
    () => getRef(obj, key),
    (value) => {
      updateRef(obj, key, value);
    },
  );

  if (!options.property && initialVal !== undefined) {
    obj[key] = initialVal;
  }
}

Object.keys(this.static.refs).forEach((prop) => {
      const refs = getModelMetaKey(this, 'refs');
      if (prop in refs) {
        return;
      }
      const ref = this.static.refs[prop];
      const data = mapItems(this[prop] || this.static.defaults[prop], getModelId);
      assignComputed(this, prop);
      if (typeof ref === 'object') {
        // Back reference
        initModelRef(this, prop, {
          model: ref.model,
          property: ref.property,
          type: ReferenceType.TO_ONE_OR_MANY,
        }, data);
      } else {
        // Normal reference
        initModelRef(this, prop, {
          model: ref,
          type: ReferenceType.TO_ONE_OR_MANY,
        }, data);
      }
    });

Object.keys(this.links).forEach((link: string) => {
        assignComputed(this, link, () => this.__fetchLink(link));
      });
    }

this.static.types.forEach((model) => {
      const type = getModelType(model);
      assignComputed(this, type.toString(), () => this.findAll(type));
    });
  }