hippo-fw 0.9.1

data/client/hippo/models/__mocks__/sync.js

@@ -0,0 +1,17 @@
+/* global jest */
+
+let nextResponse = {
+    success: true,
+    data: {},
+    message: 'success',
+};
+
+export default {
+    forModel: jest.fn(() => Promise.resolve(nextResponse)),
+    forCollection: jest.fn(() => Promise.resolve(nextResponse)),
+    perform: jest.fn(() => Promise.resolve(nextResponse)),
+
+    setResponseData(response) {
+        nextResponse = response;
+    },
+};

data/client/hippo/models/asset.js

@@ -0,0 +1,104 @@
+import { includes, get, isEmpty } from 'lodash';
+import qs from 'qs';
+import { observe } from 'mobx';
+import {
+    BaseModel, identifiedBy, field, session, identifier, computed,
+} from './base';
+import Config from '../config';
+
+const IMAGES = [
+    'image/png', 'image/jpeg', 'image/gif',
+];
+
+const IS_IMAGE = content_type => !!(content_type && (-1 !== IMAGES.indexOf(content_type)));
+
+const UPDATE_METHODS = { POST: true, PUT: true, PATCH: true };
+
+@identifiedBy('hippo/asset')
+export default class Asset extends BaseModel {
+
+    @identifier id;
+    @field order;
+    @session file_data;
+
+    @session file;
+
+    @session({ type: 'object' }) file_data;
+    @session metadata;
+
+    @field({ type: 'object' }) owner;
+    @field owner_association_name;
+
+    constructor(props) {
+        super(props);
+
+        observe(this, 'owner', ({ newValue: owner }) => {
+            if (this.ownerSaveDisposer) { this.ownerSaveDisposer(); }
+            if (!owner || !owner.isModel) { return; }
+            this.ownerSaveDisposer = observe(owner, 'syncInProgress', ({ newValue, oldValue }) => {
+                if (this.isDirty &&
+                    !this.syncInProgress &&
+                    !oldValue &&
+                    newValue && newValue.isUpdate
+                   ) {
+                    newValue.whenComplete(() => this.save());
+                }
+            });
+        }, true);
+    }
+
+    @computed get baseUrl() {
+        return Config.api_host + Config.api_path + Config.assets_path_prefix;
+    }
+
+    @computed get isDirty() {
+        return !!this.file;
+    }
+
+    @computed get isImage() {
+        return includes(IMAGES, this.mimeType);
+    }
+
+    @computed get mimeType() {
+        return get(
+            this, 'file.type',
+            get(this, 'file_data.original.metadata.mime_type'),
+        );
+    }
+
+    @computed get previewUrl() {
+        return get(this, 'file.preview', this.urlFor('thumbnail'));
+    }
+
+    urlFor(type = 'original') {
+        const url = get(this, `file_data.${type}.id`);
+        return url ? `${this.baseUrl}/${url}` : null;
+    }
+
+    save() {
+        if (!this.file) { return Promise.resolve(this); }
+        const form = new FormData();
+
+        if (this.id) { form.append('id', this.id); }
+        form.append('file', this.file, this.file.name);
+        form.append('owner_type', this.owner.constructor.identifiedBy);
+        form.append('owner_id', this.owner.identifierFieldValue);
+        form.append('owner_association', this.owner_association_name);
+
+        let url = `${Config.api_path}${Config.assets_path_prefix}`;
+        const query   = {};
+        if (Config.access_token) {
+            query.jwt = Config.access_token;
+        }
+        if (!isEmpty(query)) {
+            url += `?${qs.stringify(query, { arrayFormat: 'brackets' })}`;
+        }
+        return fetch(url, { method: 'POST', body: form })
+            .then(resp => resp.json())
+            .then((json) => {
+                this.file = undefined;
+                return json;
+            }).then(json => this.set(json.data));
+    }
+
+}

data/client/hippo/models/base.js

@@ -0,0 +1,142 @@
+import PropTypes from 'prop-types';
+import {
+    findModel,
+} from 'mobx-decorated-models';
+import invariant from 'invariant';
+import {
+    isEmpty, isNil, find, extend, assign, pick, map, isArray,
+} from 'lodash';
+
+import { action, observable, computed } from 'mobx';
+
+import pluralize from 'pluralize';
+
+import Sync from './sync';
+import Config from '../config';
+import { toSentence, humanize } from '../lib/util';
+import ModelCollection from './collection';
+
+export {
+    identifiedBy, belongsTo, hasMany,
+} from 'mobx-decorated-models';
+export {
+    action, autorun,
+} from 'mobx';
+export {
+    field, session, identifier,
+} from './decorators';
+
+export {
+    observable, computed,
+};
+
+export class BaseModel {
+
+    static get propType() {
+        return PropTypes.instanceOf(this);
+    }
+
+    static findDerived(name) {
+        return findModel(name);
+    }
+
+    static get assignableKeys() {
+        return this.$schema.keys();
+    }
+
+    static get propertyOptions() {
+        const options = {};
+        this.$schema.forEach((val, name) => (options[name] = val.options));
+        return options;
+    }
+
+    static get syncUrl() {
+        invariant(this.identifiedBy, 'must have an identifiedBy property in order to calulate syncUrl');
+        return `${Config.api_path}/${pluralize(this.identifiedBy)}`;
+    }
+
+    static get identifierFieldName() {
+        const field = find(this.$schema.values(), { type: 'identifier' });
+        invariant(field, 'identifierFieldName called on a model that has not designated one with `@identifier`');
+        return field.name;
+    }
+
+    static get Collection() {
+        return this.$collection || (this.$collection = new ModelCollection(this));
+    }
+
+    constructor(attrs) {
+        if (!isEmpty(attrs)) { this.set(attrs); }
+    }
+
+    get isModel() { return true; }
+
+    @observable syncInProgress = false;
+    @observable lastServerMessage = '';
+    @observable errors = {};
+
+    @computed get errorMessage() {
+        return this.errors ? toSentence(map(this.errors, (v, k) => `${humanize(k)} ${v}`)) : '';
+    }
+
+    @computed get isValid() {
+        return isNil(this.errors) || isEmpty(this.errors);
+    }
+
+    @computed get isNew() {
+        return isNil(this.identifierFieldValue);
+    }
+
+    @computed get identifierFieldValue() {
+        return this[this.constructor.identifierFieldName];
+    }
+
+    @computed get syncUrl() {
+        const path = this.constructor.syncUrl;
+        return this.isNew ? path : `${path}/${this.identifierFieldValue}`;
+    }
+
+    set(attrs = {}) {
+        assign(this, pick(attrs, this.constructor.assignableKeys));
+        return this;
+    }
+
+    @action reset() {
+        this.constructor.assignableKeys.forEach(k => (this[k] = null));
+    }
+
+    set syncData(data) {
+        if (!data) { return this; }
+        if (isArray(data) && data.length) {
+            this.update(data[0]);
+        } else {
+            this.update(data);
+        }
+        return this;
+    }
+
+    @computed
+    get syncData() {
+        return this.serialize();
+    }
+
+    fetch(options = {}) {
+        invariant((!this.isNew || options.query),
+                  'Unable to fetch record without it’s identifier being set or a query');
+        const fetchOptions = extend(options, { limit: 1, method: 'GET' });
+        if (!fetchOptions.query) {
+            fetchOptions.query = { [`${this.constructor.identifierFieldName}`]: this.identifierFieldValue };
+        }
+        return Sync.forModel(this, fetchOptions);
+    }
+
+    save(options = {}) {
+        return Sync.forModel(this, options);
+    }
+
+    destroy(options = {}) {
+        return Sync.forModel(this, extend(options, { action: 'destroy' }));
+    }
+}
+
+export default BaseModel;

data/client/hippo/models/collection.js

@@ -0,0 +1,58 @@
+import { observable } from 'mobx';
+import invariant from 'invariant';
+import { extend, each, isArray, isObject, isEmpty } from 'lodash';
+import { createCollection } from 'mobx-decorated-models';
+
+import Sync from './sync';
+
+function extendAry(modelClass, models = [], options = {}) {
+    invariant(isArray(models), 'models must be an array');
+    const ary = createCollection(extend({ model: modelClass }, options));
+
+    if (models.length) {
+        ary.replace(models);
+    }
+
+    ary.$map = observable.map({
+        lastServerMessage: '',
+        syncInProgress:    '',
+        errors:            {},
+    });
+    ary.$map.keys().forEach((prop) => {
+        Object.defineProperty(ary, prop, {
+            get() { return this.$map.get(prop); },
+            set(val) { return this.$map.set(prop, val); },
+        });
+    });
+    Object.defineProperties(ary, {
+        syncUrl: {
+            get() { return modelClass.syncUrl; },
+        },
+        syncData: {
+            set(rows) {
+                this.replace(rows);
+            },
+        },
+    });
+    ary.fetch = function(fetchOptions = {}) {
+        return Sync.forCollection(this, fetchOptions);
+    };
+    if (options.fetch) {
+        ary.fetch(isObject(options.fetch) ? options.fetch : {});
+    }
+    return ary;
+}
+
+export default class ModelCollection {
+    constructor(model) {
+        this.$model = model;
+        this.$collection = extendAry(model, [], {}, this);
+        return this;
+    }
+    create(models = [], options = {}) {
+        if (isObject(models) && isEmpty(options)) {
+            return extendAry(this.$model, [], models, this);
+        }
+        return extendAry(this.$model, models, options, this);
+    }
+}

data/client/hippo/models/decorators.js

@@ -0,0 +1,72 @@
+import {
+    isEmpty, isArray, isNumber, isObject, isString, partial, defaults, isNil, isDate,
+} from 'lodash';
+import invariant from 'invariant';
+
+import { intercept, isObservableArray, isObservableObject } from 'mobx';
+
+import {
+    field as mobxField,
+    session as mobxSession,
+    identifier as mobxIdentifier,
+} from 'mobx-decorated-models';
+
+const VALIDATORS = {
+    number: isNumber,
+    string: isString,
+    array(a) { return isArray(a) || isObservableArray(a); },
+    object(o) { return isObject(o) || isObservableObject(o); },
+    date:   isDate,
+};
+
+const COERCE = {
+    date(change) {
+        if (!isDate(change.newValue)) {
+            change.newValue = new Date(change.newValue); // eslint-disable-line no-param-reassign
+        }
+    },
+};
+
+function addLazyInitializer(target, fn) {
+    target.__mobxLazyInitializers.push(fn);
+}
+
+function validateChangeType(validator, propertyName, change) {
+    if (isNil(change.newValue)) { return change; }
+    invariant(VALIDATORS[validator], `Unknown TypeCheck: ${validator} does not exist`);
+    if (COERCE[validator]) { COERCE[validator](change); }
+    invariant(VALIDATORS[validator](change.newValue),
+              `Bad Type: Attempted to set ${propertyName} to '${change.newValue}' which is not ${validator}`);
+    return change;
+}
+
+function addTypeSafeInterceptor(target, property, type) {
+    if (isEmpty(type)) { return; }
+    addLazyInitializer(target, (partial(intercept, partial.placeholder, property,
+                                        partial(validateChangeType, type, property))));
+}
+
+function decoratorWrapper(decorator, defaultOptions = {}) {
+    return (targetOrOptions, ...args) => {
+        const options = isEmpty(args) ?
+              defaults(targetOrOptions, defaultOptions) : defaultOptions;
+
+        const wrap = (target, property, descriptor) => {
+            const decorationFn = decorator(options);
+            const description = decorationFn(target, property, descriptor);
+            addTypeSafeInterceptor(target, property, options.type);
+            return description;
+        };
+
+        if (isEmpty(args)) { // we were given options
+            return (target, property, descriptor) => wrap(target, property, descriptor);
+        }
+        return wrap(targetOrOptions, args[0], args[1]);
+    };
+}
+
+const field = decoratorWrapper(mobxField);
+const session = decoratorWrapper(mobxSession);
+const identifier = decoratorWrapper(mobxIdentifier, { type: 'number' });
+
+export { field, session, identifier };

data/client/hippo/models/index.js

@@ -0,0 +1,10 @@
+//= require_self
+//= require_tree ./mixins
+//= require ./Sync
+//= require ./ServerCache
+//= require ./AssociationMap
+//= require ./EnumMap
+//= require ./State
+//= require ./Base
+//= require ./Collection
+//= require_tree .

data/client/hippo/models/query.js

@@ -0,0 +1,116 @@
+import { get, isString, find, extend, toPairs } from 'lodash';
+import { action, reaction, observe } from 'mobx';
+import {
+    BaseModel, identifiedBy, field, belongsTo, hasMany, identifier, computed, session,
+} from './base';
+
+import Info        from './query/info';
+import Types       from './query/types';
+import Operator    from './query/operator';
+import Clause      from './query/clause';
+import Field       from './query/field';
+import ArrayResult from './query/array-result';
+
+// needs to inherit from Base so network events will be listened to
+@identifiedBy('hippo/query')
+export default class Query extends BaseModel {
+
+    @belongsTo src;
+
+    @identifier id;
+    @session pageSize = 20;
+
+    @session initialField;
+    @session idIndex;
+    @session initialFieldIndex;
+
+    @session sortField;
+    @session sortAscending = false;
+
+    @session results;
+    @session customSyncUrl;
+
+    @session autoFetch = false;
+
+    @field({ type: 'object' }) syncOptions = {};
+
+    @hasMany({ model: Clause, inverseOf: 'query' }) clauses;
+    @hasMany({ model: Operator, inverseOf: 'query' }) operators;
+    @hasMany({ model: Field, inverseOf: 'query' }) fields;
+
+    @action
+    setSort({ field: f, ascending }) {
+        this.sortField = f;
+        this.sortAscending = ascending;
+    }
+
+    constructor(attrs = {}) {
+        for (let i = 0; i < get(attrs, 'fields.length', 0); i += 1) {
+            if (isString(attrs.fields[i])) {
+                attrs.fields[i] = { id: attrs.fields[i] }; // eslint-disable-line no-param-reassign
+            }
+        }
+        super(attrs);
+        [
+            { id: 'like', label: 'Starts With', types: Types.LIKE_QUERY_TYPES },
+            { id: 'eq', label: 'Equals' },
+            { id: 'lt', label: 'Less Than', types: Types.LESS_THAN_QUERY_TYPES },
+            { id: 'gt', label: 'More Than', types: Types.LESS_THAN_QUERY_TYPES },
+        ].forEach(op => this.operators.push(op));
+        this.info = new Info(this);
+        this.results = new ArrayResult({ query: this });
+        if (0 === this.clauses.length) {
+            this.clauses.push({ });
+        }
+        if (attrs.sort) {
+            const [fieldId, dir] = toPairs(attrs.sort)[0];
+            this.sortField = find(this.fields, { id: fieldId });
+            this.sortAscending = ('ASC' === dir);
+        }
+        observe(this, 'autoFetch', this._onAutoFetchChange);
+    }
+
+    @computed get fingerprint() {
+        return this.clauses.map(o => o.fingerprint).join(';');
+    }
+
+    open() {
+        if (this.autoFetch) { this._startAutoFetch(); }
+    }
+
+    close() {
+        if (this.autoFetchDisposer) {
+            this.autoFetchDisposer();
+            this.autoFetchDisposer = undefined;
+        }
+    }
+
+    @action.bound
+    fetch() {
+        return this.results.fetch({ start: 0 });
+    }
+
+    fetchSingle(query, queryOptions = {}) {
+        const options = extend(queryOptions, this.syncOptions, { query });
+        const { src: Src } = this;
+        const model = new Src();
+        return model.fetch(options);
+    }
+
+    @action.bound
+    _onAutoFetchChange(change) {
+        if (change.newValue) {
+            this._startAutoFetch();
+        } else if (this.autoFetchDisposer) {
+            this.autoFetchDisposer();
+        }
+    }
+
+    _startAutoFetch() {
+        this.autoFetchDisposer = reaction(
+            () => this.fingerprint,
+            this.fetch,
+            { delay: 100, compareStructural: true, fireImmediately: true },
+        );
+    }
+}