@ngageoint/mage.service 6.2.2

package/lib/entities/observations/entities.observations.js

@@ -0,0 +1,873 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Observation_validation, _Observation_formEntriesById, _Observation_attachmentsById, _FormEntryValidationError_entryLevelErrors, _FormEntryValidationError_fieldErrors, _ObservationValidationContext_coreAttrsErrors, _ObservationValidationContext_formCountErrors, _ObservationValidationContext_formEntryErrors, _ObservationValidationContext_attachmentErrors, _ObservationValidationContext_totalFormCountError;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentStoreErrorCode = exports.AttachmentStoreError = exports.StagedAttachmentContent = exports.StagedAttachmentContentRef = exports.ObservationRepositoryErrorCode = exports.ObservationRepositoryError = exports.AttachmentNotFoundError = exports.AttachmentAddError = exports.thumbnailIndexForTargetDimension = exports.putAttachmentThumbnailForMinDimension = exports.removeAttachment = exports.patchAttachment = exports.addAttachment = exports.removeFormEntry = exports.attachmentsForField = exports.formEntryForId = exports.ObservationUpdateErrorReason = exports.ObservationUpdateError = exports.validationResultMessage = exports.AttachmentValidationError = exports.AttachmentValidationErrorReason = exports.FormFieldValidationError = exports.FieldConstraintKey = exports.FormEntryValidationErrorReason = exports.FormEntryValidationError = exports.FormCountError = exports.TotalFormCountError = exports.MaxFormsConstraint = exports.MinFormsConstraint = exports.validateObservation = exports.ObservationDomainEventType = exports.Observation = exports.copyImportantFlagAttrs = exports.copyObservationStateAttrs = exports.copyThumbnailAttrs = exports.copyAttachmentAttrs = exports.copyObservationAttrs = void 0;
+const entities_global_1 = require("../entities.global");
+const entities_events_forms_1 = require("../events/entities.events.forms");
+const fields = __importStar(require("./entities.observations.fields"));
+function copyObservationAttrs(from) {
+    return {
+        id: from.id,
+        eventId: from.eventId,
+        userId: from.userId,
+        deviceId: from.deviceId,
+        createdAt: new Date(from.createdAt.getTime()),
+        lastModified: new Date(from.lastModified.getTime()),
+        attachments: from.attachments.map(copyAttachmentAttrs),
+        important: from.important ? copyImportantFlagAttrs(from.important) : undefined,
+        favoriteUserIds: Object.freeze([...from.favoriteUserIds]),
+        states: Object.freeze(from.states.map(copyObservationStateAttrs)),
+        type: 'Feature',
+        // meh, these shallow copies are probably fine ... right?
+        geometry: Object.freeze(Object.assign({}, from.geometry)),
+        properties: Object.assign(Object.assign({}, from.properties), { forms: from.properties.forms.map(x => (Object.assign({}, x))), timestamp: new Date(from.properties.timestamp) })
+    };
+}
+exports.copyObservationAttrs = copyObservationAttrs;
+function copyAttachmentAttrs(from) {
+    return {
+        id: from.id,
+        fieldName: from.fieldName,
+        observationFormId: from.observationFormId,
+        lastModified: from.lastModified ? new Date(from.lastModified) : undefined,
+        contentType: from.contentType,
+        name: from.name,
+        size: from.size,
+        width: from.width,
+        height: from.height,
+        oriented: from.oriented,
+        thumbnails: from.thumbnails.map(copyThumbnailAttrs),
+        contentLocator: from.contentLocator
+    };
+}
+exports.copyAttachmentAttrs = copyAttachmentAttrs;
+function copyThumbnailAttrs(from) {
+    return {
+        minDimension: from.minDimension,
+        contentLocator: from.contentLocator,
+        contentType: from.contentType,
+        name: from.name,
+        size: from.size,
+        width: from.width,
+        height: from.height
+    };
+}
+exports.copyThumbnailAttrs = copyThumbnailAttrs;
+function copyObservationStateAttrs(from) {
+    return {
+        id: from.id,
+        name: from.name,
+        userId: from.userId
+    };
+}
+exports.copyObservationStateAttrs = copyObservationStateAttrs;
+function copyImportantFlagAttrs(from) {
+    return {
+        userId: from.userId,
+        description: from.description,
+        timestamp: from.timestamp ? new Date(from.timestamp.getTime()) : undefined
+    };
+}
+exports.copyImportantFlagAttrs = copyImportantFlagAttrs;
+/**
+ * The intention of this class is to provide a mutation model for observation
+ * updates.  While `ObservationAttrs` is more just raw the keys and values of
+ * observations, this class retains some extra context for validation so
+ * the client can make changes to the observation data while receiving
+ * validation feedback for every operation performed on the observation.
+ * TODO: add domain event tracking to this class
+ */
+class Observation {
+    constructor(...args) {
+        _Observation_validation.set(this, void 0);
+        _Observation_formEntriesById.set(this, void 0);
+        _Observation_attachmentsById.set(this, void 0);
+        this.type = 'Feature';
+        if (args[0] !== ObservationConstructionToken) {
+            throw new Error('use a factory function to create an observation instance');
+        }
+        const attrs = args[1];
+        this.mageEvent = args[2];
+        this.id = attrs.id;
+        this.eventId = attrs.eventId;
+        this.userId = attrs.userId;
+        this.deviceId = attrs.deviceId;
+        this.createdAt = new Date(attrs.createdAt);
+        this.lastModified = new Date(attrs.lastModified);
+        this.important = attrs.important ? Object.freeze(Object.assign({}, attrs.important)) : undefined;
+        const states = attrs.states.length ? attrs.states.map(copyObservationStateAttrs) : [
+            {
+                id: entities_global_1.PendingEntityId,
+                name: 'active',
+                userId: attrs.userId
+            }
+        ];
+        this.states = Object.freeze(states);
+        this.favoriteUserIds = Object.freeze(attrs.favoriteUserIds.slice());
+        this.type = 'Feature';
+        this.bbox = attrs.bbox;
+        this.geometry = attrs.geometry;
+        this.attachments = Object.freeze([...attrs.attachments]);
+        this.properties = Object.assign({}, attrs.properties);
+        __classPrivateFieldSet(this, _Observation_formEntriesById, new Map(this.properties.forms.map(x => [x.id, x])), "f");
+        __classPrivateFieldSet(this, _Observation_attachmentsById, new Map(this.attachments.map(x => [x.id, x])), "f");
+        __classPrivateFieldSet(this, _Observation_validation, args[3], "f");
+        this.pendingEvents = (args[4] || []);
+    }
+    /**
+     * Validate the given observation attributes against the given MAGE event's
+     * constraints and forms, and create the corresponding `Observation` instance
+     * with the validation result.
+     * @param attrs
+     * @param mageEvent
+     */
+    static evaluate(attrs, mageEvent) {
+        return createObservation(attrs, mageEvent);
+    }
+    /**
+     * TODO: This does not currently do anything besides assigning the
+     * `lastModified` timestamp on the updated observation and calling
+     * {@link Observation.evaluate()} with the given update attributes.
+     * Eventually this should perform the logic to find the differences and
+     * produce the domain events resulting from updating the target observation
+     * to the update attributes.
+     *
+     * Return an {@link ObservationUpdateError} if the event IDs on the target
+     * and udpate do not match.
+     *
+     * @param target
+     * @param update
+     * @returns
+     */
+    static assignTo(target, update) {
+        if (update.eventId !== target.eventId) {
+            return ObservationUpdateError.eventIdMismatch(target.eventId, update.eventId);
+        }
+        update = Object.assign(Object.assign({}, update), { createdAt: new Date(target.createdAt), lastModified: new Date() });
+        const updateAttachments = update.attachments.reduce((updateAttachments, att) => {
+            return updateAttachments.set(att.id, att);
+        }, new Map());
+        const removedAttachments = target.attachments.filter(x => !updateAttachments.has(x.id));
+        // TODO: whatever other mods generate events that matter
+        const updateEvents = removedAttachments.length ? [AttachmentsRemovedDomainEvent(target, removedAttachments)] : [];
+        const pendingEvents = mergePendingDomainEvents(target, updateEvents);
+        return createObservation(update, target.mageEvent, pendingEvents);
+    }
+    get validation() {
+        return __classPrivateFieldGet(this, _Observation_validation, "f");
+    }
+    /**
+     * This is a convenience accessor for {@link ObservationFeatureProperties.timestamp}.
+     */
+    get timestamp() {
+        return this.properties.timestamp;
+    }
+    /**
+     * This is a convenience accessor for {@link ObservationFeatureProperties.forms}.
+     */
+    get formEntries() {
+        return Array.from(__classPrivateFieldGet(this, _Observation_formEntriesById, "f").values());
+    }
+    formEntryForId(id) {
+        return __classPrivateFieldGet(this, _Observation_formEntriesById, "f").get(id) || null;
+    }
+    attachmentFor(id) {
+        return __classPrivateFieldGet(this, _Observation_attachmentsById, "f").get(id) || null;
+    }
+    attachmentsForField(fieldName, formEntryId) {
+        return attachmentsForField(fieldName, formEntryId, this);
+    }
+}
+exports.Observation = Observation;
+_Observation_validation = new WeakMap(), _Observation_formEntriesById = new WeakMap(), _Observation_attachmentsById = new WeakMap();
+var ObservationDomainEventType;
+(function (ObservationDomainEventType) {
+    ObservationDomainEventType["AttachmentsRemoved"] = "Observation.AttachmentsRemoved";
+})(ObservationDomainEventType = exports.ObservationDomainEventType || (exports.ObservationDomainEventType = {}));
+function validateObservation(observationAttrs, mageEvent) {
+    const validation = validateObservationFormEntries(validateObservationAttachments(validateObservationCoreAttrs(new ObservationValidationContext(observationAttrs, mageEvent))));
+    return validation.result();
+}
+exports.validateObservation = validateObservation;
+exports.MinFormsConstraint = Symbol('ObservationValidation.MinForms');
+exports.MaxFormsConstraint = Symbol('ObservationValidation.MaxForms');
+class TotalFormCountError {
+    constructor(constraint, constraintCount) {
+        this.constraint = constraint;
+        this.constraintCount = constraintCount;
+    }
+    static tooFewFormEntries(mageEvent) {
+        return new TotalFormCountError(exports.MinFormsConstraint, Number(mageEvent.minObservationForms));
+    }
+    static tooManyFormEntries(mageEvent) {
+        return new TotalFormCountError(exports.MaxFormsConstraint, Number(mageEvent.maxObservationForms));
+    }
+    message() {
+        if (this.constraint === exports.MinFormsConstraint) {
+            return `The event requires at least ${this.constraintCount} form ${this.constraintCount > 1 ? 'entries' : 'entry'}.`;
+        }
+        return `The event allows at most ${this.constraintCount} form ${this.constraintCount > 1 ? 'entries' : 'entry'}.`;
+    }
+}
+exports.TotalFormCountError = TotalFormCountError;
+class FormCountError {
+    constructor(constraint, constraintCount, formId, formName) {
+        this.constraint = constraint;
+        this.constraintCount = constraintCount;
+        this.formId = formId;
+        this.formName = formName;
+    }
+    static tooFewEntriesForForm(form) {
+        return new FormCountError(exports.MinFormsConstraint, Number(form.min), form.id, form.name);
+    }
+    static tooManyEntriesForForm(form) {
+        return new FormCountError(exports.MaxFormsConstraint, Number(form.max), form.id, form.name);
+    }
+    message() {
+        if (this.constraint === exports.MinFormsConstraint) {
+            return `The event requires at least ${this.constraintCount} ${this.formName} form ${this.constraintCount > 1 ? 'entries' : 'entry'}.`;
+        }
+        return `The event allows at most ${this.constraintCount} ${this.formName} form ${this.constraintCount > 1 ? 'entries' : 'entry'}.`;
+    }
+}
+exports.FormCountError = FormCountError;
+class FormEntryValidationError {
+    constructor(formEntryId, formEntryPosition) {
+        this.formEntryId = formEntryId;
+        this.formEntryPosition = formEntryPosition;
+        _FormEntryValidationError_entryLevelErrors.set(this, new Set());
+        _FormEntryValidationError_fieldErrors.set(this, new Map()
+        /**
+         * If there is no form reference error, set the form name for convenience
+         * when building the validation error message text.
+         */
+        );
+        /**
+         * If there is no form reference error, set the form name for convenience
+         * when building the validation error message text.
+         */
+        this.formName = null;
+    }
+    addEntryLevelError(x) {
+        __classPrivateFieldGet(this, _FormEntryValidationError_entryLevelErrors, "f").add(x);
+        return this;
+    }
+    addFieldError(x) {
+        __classPrivateFieldGet(this, _FormEntryValidationError_fieldErrors, "f").set(x.fieldName, x);
+        return this;
+    }
+    get entryLevelErrors() {
+        return new Set(__classPrivateFieldGet(this, _FormEntryValidationError_entryLevelErrors, "f"));
+    }
+    /**
+     * This is a map of field names to form field validation errors.
+     */
+    get fieldErrors() {
+        return new Map(__classPrivateFieldGet(this, _FormEntryValidationError_fieldErrors, "f"));
+    }
+}
+exports.FormEntryValidationError = FormEntryValidationError;
+_FormEntryValidationError_entryLevelErrors = new WeakMap(), _FormEntryValidationError_fieldErrors = new WeakMap();
+var FormEntryValidationErrorReason;
+(function (FormEntryValidationErrorReason) {
+    FormEntryValidationErrorReason["FormRef"] = "FormEntryValidationErrorReason.FormRef";
+    FormEntryValidationErrorReason["DuplicateId"] = "FormEntryValidationErrorReason.DuplicateId";
+})(FormEntryValidationErrorReason = exports.FormEntryValidationErrorReason || (exports.FormEntryValidationErrorReason = {}));
+var FieldConstraintKey;
+(function (FieldConstraintKey) {
+    FieldConstraintKey["Value"] = "value";
+    FieldConstraintKey["Min"] = "min";
+    FieldConstraintKey["Max"] = "max";
+    FieldConstraintKey["Required"] = "required";
+})(FieldConstraintKey = exports.FieldConstraintKey || (exports.FieldConstraintKey = {}));
+class FormFieldValidationError {
+    constructor(attrs) {
+        this.fieldName = attrs.fieldName;
+        this.constraint = attrs.constraint;
+        this.message = attrs.message;
+    }
+    /**
+     * `error` is a readonly accessor alias for `validationRuleKey` for backward
+     * compatibility.
+     * TODO: verify this is still necessary (NECESSARY?!)
+     */
+    get error() {
+        return this.constraint;
+    }
+}
+exports.FormFieldValidationError = FormFieldValidationError;
+var AttachmentValidationErrorReason;
+(function (AttachmentValidationErrorReason) {
+    AttachmentValidationErrorReason["FieldRef"] = "AttachmentValidationErrorReason.FieldRef";
+    AttachmentValidationErrorReason["FormEntryRef"] = "AttachmentValidationErrorReason.FormEntryRef";
+    AttachmentValidationErrorReason["DuplicateId"] = "AttachmentValidationErrorReason.DuplicateId";
+})(AttachmentValidationErrorReason = exports.AttachmentValidationErrorReason || (exports.AttachmentValidationErrorReason = {}));
+class AttachmentValidationError {
+    constructor(reason, message) {
+        this.reason = reason;
+        this.message = message;
+    }
+}
+exports.AttachmentValidationError = AttachmentValidationError;
+function validationResultMessage(result) {
+    const { coreAttrsErrors, totalFormCountError, formCountErrors, formEntryErrors, attachmentErrors, } = result;
+    const bulletPoint = '\u2022';
+    const errList = [];
+    for (const message of Object.values(coreAttrsErrors)) {
+        errList.push(`${bulletPoint} ${message}`);
+    }
+    if (totalFormCountError) {
+        errList.push(`${bulletPoint} ${totalFormCountError.message()}`);
+    }
+    for (const [formId, err] of formCountErrors) {
+        errList.push(`${bulletPoint} ${err.message()}`);
+    }
+    for (const [formEntryId, formEntryErr] of formEntryErrors) {
+        errList.push(`${bulletPoint} Form entry ${formEntryErr.formEntryPosition + 1} (${formEntryErr.formName}) is invalid.`);
+        for (const fieldErr of formEntryErr.fieldErrors.values()) {
+            errList.push(`  ${bulletPoint} ${fieldErr.message}`);
+        }
+    }
+    for (const [pos, attachmentErr] of attachmentErrors) {
+        errList.push(`${bulletPoint} Attachment ${pos + 1} is invalid.  ${attachmentErr.message}`);
+    }
+    return errList.join('\n');
+}
+exports.validationResultMessage = validationResultMessage;
+class ObservationUpdateError extends Error {
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+    static eventIdMismatch(expected, actual) {
+        return new ObservationUpdateError(ObservationUpdateErrorReason.EventId, `The update event ID ${actual} does not match the target event ID ${expected}.`);
+    }
+}
+exports.ObservationUpdateError = ObservationUpdateError;
+var ObservationUpdateErrorReason;
+(function (ObservationUpdateErrorReason) {
+    ObservationUpdateErrorReason["EventId"] = "event_id";
+})(ObservationUpdateErrorReason = exports.ObservationUpdateErrorReason || (exports.ObservationUpdateErrorReason = {}));
+function formEntryForId(formEntryId, observation) {
+    return observation.properties.forms.find(x => x.id === formEntryId) || null;
+}
+exports.formEntryForId = formEntryForId;
+function attachmentsForField(field, formEntry, observationAttrs) {
+    const fieldName = typeof field === 'object' ? field.name : field;
+    const formEntryId = typeof formEntry === 'object' && 'id' in formEntry && 'formId' in formEntry ? formEntry.id : formEntry;
+    return observationAttrs.attachments.filter(x => x.fieldName === fieldName && x.observationFormId === formEntryId);
+}
+exports.attachmentsForField = attachmentsForField;
+/**
+ * Remove the form entry with the given ID and return the resulting
+ * (potentially invalid) observation.
+ *
+ * TODO: add a `FormEntryNotFound` error similar to `removeAttachment()`
+ */
+function removeFormEntry(observation, formEntryId) {
+    const mod = copyObservationAttrs(observation);
+    const targetPos = observation.formEntries.findIndex(x => x.id === formEntryId);
+    mod.properties.forms.splice(targetPos, 1);
+    mod.attachments = observation.attachments.filter(x => x.observationFormId !== formEntryId);
+    return Observation.assignTo(observation, mod);
+}
+exports.removeFormEntry = removeFormEntry;
+/**
+ * Add the given attachment to the given observation.  Return a new observation
+ * instance with the added attachment, or return an {@link AttachmentAddError}
+ * if the given attachment does not reference a valid form entry and field.
+ * Note that the returned observation may still have validation errors resulting
+ * from the added attachment if the attachment violates the associated form
+ * constraints, such as min/max or allowed attachment types.
+ * @param observation
+ * @param fieldName
+ * @param formEntryId
+ * @param attrs
+ * @returns
+ */
+function addAttachment(observation, attachmentId, fieldName, formEntryId, attrs) {
+    const attachment = Object.assign(Object.assign({}, attrs), { id: attachmentId, fieldName, observationFormId: formEntryId, lastModified: new Date() });
+    const invalid = validateAttachment(attachment, observation, observation.mageEvent);
+    if (invalid) {
+        return AttachmentAddError.invalidNewAttachment(invalid);
+    }
+    const mod = copyObservationAttrs(observation);
+    mod.attachments = [...mod.attachments, attachment];
+    return Observation.assignTo(observation, mod);
+}
+exports.addAttachment = addAttachment;
+/**
+ * Update the attachment for the given ID with the given patch object.  Keys
+ * that are present in the patch whose values are `undefined` will assign
+ * `undefined` to the resulting updated attachment.  Keys not present in the
+ * patch will have no affect on the resulting updated attachment.
+ * @param observation
+ * @param attachmentId
+ * @param patch
+ * @returns
+ */
+function patchAttachment(observation, attachmentId, patch) {
+    var _a;
+    const targetPos = observation.attachments.findIndex(x => x.id === attachmentId);
+    const target = observation.attachments[targetPos];
+    if (!target) {
+        return new AttachmentNotFoundError(attachmentId);
+    }
+    const patched = copyAttachmentAttrs(target);
+    patched.contentType = patch.hasOwnProperty('contentType') ? patch.contentType : patched.contentType;
+    patched.height = patch.hasOwnProperty('height') ? patch.height : patched.height;
+    patched.width = patch.hasOwnProperty('width') ? patch.width : patched.width;
+    patched.name = patch.hasOwnProperty('name') ? patch.name : patched.name;
+    patched.oriented = patch.hasOwnProperty('oriented') ? !!patch.oriented : patched.oriented;
+    patched.size = patch.hasOwnProperty('size') ? patch.size : patched.size;
+    patched.contentLocator = patch.hasOwnProperty('contentLocator') ? patch.contentLocator : patched.contentLocator;
+    patched.thumbnails = patch.hasOwnProperty('thumbnails') ? (_a = patch.thumbnails) === null || _a === void 0 ? void 0 : _a.map(copyThumbnailAttrs) : patched.thumbnails;
+    patched.lastModified = new Date();
+    const patchedObservation = copyObservationAttrs(observation);
+    const before = patchedObservation.attachments.slice(0, targetPos);
+    const after = patchedObservation.attachments.slice(targetPos + 1);
+    const attachments = before.concat(patched, after);
+    patchedObservation.attachments = Object.freeze(attachments);
+    patchedObservation.lastModified = new Date(patched.lastModified);
+    return Observation.assignTo(observation, patchedObservation);
+}
+exports.patchAttachment = patchAttachment;
+function removeAttachment(observation, attachmentId) {
+    const targetPos = observation.attachments.findIndex(x => x.id === attachmentId);
+    const target = observation.attachments[targetPos];
+    if (!target) {
+        return new AttachmentNotFoundError(attachmentId);
+    }
+    const afterAttrs = copyObservationAttrs(observation);
+    const attachments = afterAttrs.attachments.slice();
+    attachments.splice(targetPos, 1);
+    afterAttrs.attachments = attachments;
+    return Observation.assignTo(observation, afterAttrs);
+}
+exports.removeAttachment = removeAttachment;
+/**
+ * Add the given thumbnail to the given attachment.  If the attachment already
+ * has a thumbnail at the same minimum dimension as the given thumbnail,
+ * replace the existing thumbnail with the given thumbnail at the same position
+ * in the thumbnails array.
+ * @param observation
+ * @param attachmentId
+ * @param thumbnail
+ * @returns
+ */
+function putAttachmentThumbnailForMinDimension(observation, attachmentId, thumbnail) {
+    const target = observation.attachmentFor(attachmentId);
+    if (!target) {
+        return new AttachmentNotFoundError(attachmentId);
+    }
+    const thumbnailsPatch = target.thumbnails.map(copyThumbnailAttrs);
+    const targetThumbPos = thumbnailsPatch.findIndex(x => x.minDimension === thumbnail.minDimension);
+    const putThumbAttrs = copyThumbnailAttrs(thumbnail);
+    if (targetThumbPos >= 0) {
+        thumbnailsPatch[targetThumbPos] = putThumbAttrs;
+    }
+    else {
+        thumbnailsPatch.push(putThumbAttrs);
+    }
+    return patchAttachment(observation, attachmentId, { thumbnails: thumbnailsPatch });
+}
+exports.putAttachmentThumbnailForMinDimension = putAttachmentThumbnailForMinDimension;
+/**
+ * Return the index of the thumbnail on the given attachment that best satisfies
+ * the given target dimension.  That will be the thumbnail with the smallest
+ * {@link Attachment.minDimension} greater than the target dimension.
+ */
+function thumbnailIndexForTargetDimension(targetDimension, attachment) {
+    if (attachment.thumbnails.length === 0) {
+        return void (0);
+    }
+    return attachment.thumbnails.reduce((best, candidate, index) => {
+        if (candidate.minDimension >= targetDimension &&
+            (best === undefined || candidate.minDimension < attachment.thumbnails[best].minDimension)) {
+            return index;
+        }
+        return best;
+    }, void (0));
+}
+exports.thumbnailIndexForTargetDimension = thumbnailIndexForTargetDimension;
+class AttachmentAddError extends Error {
+    constructor(validationErr) {
+        super(`Invalid new attachment: ${validationErr.message}`);
+        this.validationErr = validationErr;
+    }
+    static invalidNewAttachment(invalidErr) {
+        return new AttachmentAddError(invalidErr);
+    }
+}
+exports.AttachmentAddError = AttachmentAddError;
+class AttachmentNotFoundError extends Error {
+    constructor(attachmentId) {
+        super(`Attachment ID ${attachmentId} does not exist.`);
+        this.attachmentId = attachmentId;
+    }
+}
+exports.AttachmentNotFoundError = AttachmentNotFoundError;
+class ObservationRepositoryError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+exports.ObservationRepositoryError = ObservationRepositoryError;
+var ObservationRepositoryErrorCode;
+(function (ObservationRepositoryErrorCode) {
+    ObservationRepositoryErrorCode["InvalidObservationId"] = "ObservationRepositoryError.InvalidObservationId";
+    ObservationRepositoryErrorCode["InvalidObservation"] = "ObservationRepositoryError.InvalidObservation";
+})(ObservationRepositoryErrorCode = exports.ObservationRepositoryErrorCode || (exports.ObservationRepositoryErrorCode = {}));
+class StagedAttachmentContentRef {
+    constructor(id) {
+        this.id = id;
+    }
+}
+exports.StagedAttachmentContentRef = StagedAttachmentContentRef;
+class StagedAttachmentContent extends StagedAttachmentContentRef {
+    constructor(id, tempLocation) {
+        super(id);
+        this.tempLocation = tempLocation;
+    }
+}
+exports.StagedAttachmentContent = StagedAttachmentContent;
+class AttachmentStoreError extends Error {
+    constructor(errorCode, message) {
+        super(message);
+        this.errorCode = errorCode;
+        this.name = errorCode;
+    }
+    static invalidAttachmentId(attachmentId, observation) {
+        return new AttachmentStoreError(AttachmentStoreErrorCode.InvalidAttachmentId, `observation ${observation.id} has no attachment ${attachmentId}`);
+    }
+    static invalidThumbnailDimension(minDimension, attachmentId, observation) {
+        return new AttachmentStoreError(AttachmentStoreErrorCode.InvalidThumbnailDimension, `attachment ${attachmentId} on observation ${observation.id} has no thumbnail with dimension ${minDimension}`);
+    }
+}
+exports.AttachmentStoreError = AttachmentStoreError;
+var AttachmentStoreErrorCode;
+(function (AttachmentStoreErrorCode) {
+    /**
+     * The given attachment ID was not found in the given observation's
+     * attachment list.
+     */
+    AttachmentStoreErrorCode["InvalidAttachmentId"] = "AttachmentStoreError.InvalidAttachmentId";
+    AttachmentStoreErrorCode["InvalidThumbnailDimension"] = "AttachmentStoreError.InvalidThumbnailDimension";
+    /**
+     * The content for the given attachment ID was not found in the attachment
+     * store.
+     */
+    AttachmentStoreErrorCode["ContentNotFound"] = "AttachmentStoreError.ContentNotFound";
+    /**
+     * The underlying storage system, e.g. file system, raised an error during
+     * some I/O operation.
+     */
+    AttachmentStoreErrorCode["StorageError"] = "AttachmentStoreError.StorageError";
+})(AttachmentStoreErrorCode = exports.AttachmentStoreErrorCode || (exports.AttachmentStoreErrorCode = {}));
+const ObservationConstructionToken = Symbol('ObservationConstructor');
+function createObservation(attrs, mageEvent, pendingEvents) {
+    attrs = copyObservationAttrs(attrs);
+    const validation = validateObservation(attrs, mageEvent);
+    return new Observation(ObservationConstructionToken, attrs, mageEvent, validation, pendingEvents);
+}
+function validateObservationCoreAttrs(validation) {
+    const { observationAttrs, mageEvent } = validation;
+    if (observationAttrs.eventId !== mageEvent.id) {
+        validation.addCoreAttrsError('eventId', `The observation event ID ${observationAttrs.eventId} does not match the asserted event ID ${mageEvent.id}.`);
+    }
+    if (observationAttrs.type !== 'Feature') {
+        validation.addCoreAttrsError('type', `The observation GeoJSON type must be 'Feature'.`);
+    }
+    const invalidGeometry = fields.geometry.GeometryFieldValidation({ title: 'Geometry', id: 0, name: 'geometry', required: true, type: entities_events_forms_1.FormFieldType.Geometry }, observationAttrs.geometry, { succeeded: () => null, failedBecauseTheEntry: reason => reason });
+    if (invalidGeometry) {
+        validation.addCoreAttrsError('geometry', `The observation geometry ${invalidGeometry}`);
+    }
+    if (!(observationAttrs.properties.timestamp instanceof Date)) {
+        validation.addCoreAttrsError('timestamp', 'The observation requires a valid timestamp.');
+    }
+    return validation;
+}
+function validateObservationFormEntries(validation) {
+    const { observationAttrs, mageEvent } = validation;
+    if (!Array.isArray(observationAttrs.properties.forms)) {
+        return validation.addCoreAttrsError('forms', 'The observation requires an array of form entries.');
+    }
+    const activeFormEntryCounts = mageEvent.forms.reduce((activeFormCounts, form) => {
+        if (!form.archived) {
+            activeFormCounts.set(form.id, 0);
+        }
+        return activeFormCounts;
+    }, new Map());
+    const formEntryIds = new Set();
+    const formEntryCounts = observationAttrs.properties.forms.reduce((formEntryCounts, formEntry, formEntryPos) => {
+        const formEntryError = new FormEntryValidationError(formEntry.id, formEntryPos);
+        if (formEntryIds.has(formEntry.id)) {
+            formEntryError.addEntryLevelError(FormEntryValidationErrorReason.DuplicateId);
+        }
+        formEntryIds.add(formEntry.id);
+        const form = mageEvent.formFor(formEntry.formId);
+        if (form) {
+            if (activeFormEntryCounts.has(form.id)) {
+                formEntryError.formName = form.name;
+                formEntryCounts.set(form.id, (formEntryCounts.get(form.id) || 0) + 1);
+                validateFormFieldEntries(formEntry, form, formEntryError, validation);
+            }
+        }
+        else {
+            formEntryError.addEntryLevelError(FormEntryValidationErrorReason.FormRef);
+        }
+        if (formEntryHasErrors(formEntryError)) {
+            validation.addFormEntryError(formEntryError);
+        }
+        return formEntryCounts;
+    }, activeFormEntryCounts);
+    let totalActiveFormEntryCount = 0;
+    for (const [formId, formEntryCount] of formEntryCounts) {
+        const form = mageEvent.formFor(formId);
+        if (typeof form.min === 'number' && formEntryCount < form.min) {
+            validation.addFormCountError(FormCountError.tooFewEntriesForForm(form));
+        }
+        else if (typeof form.max === 'number' && formEntryCount > form.max) {
+            validation.addFormCountError(FormCountError.tooManyEntriesForForm(form));
+        }
+        totalActiveFormEntryCount += formEntryCount;
+    }
+    if (typeof mageEvent.minObservationForms === 'number' && totalActiveFormEntryCount < mageEvent.minObservationForms) {
+        validation.setTotalFormCountError(TotalFormCountError.tooFewFormEntries(mageEvent));
+    }
+    else if (typeof mageEvent.maxObservationForms === 'number' && totalActiveFormEntryCount > mageEvent.maxObservationForms) {
+        validation.setTotalFormCountError(TotalFormCountError.tooManyFormEntries(mageEvent));
+    }
+    // TODO: invalidate new form entries that reference archived forms
+    return validation;
+}
+function formEntryHasErrors(err) {
+    return err.entryLevelErrors.size > 0 || err.fieldErrors.size > 0;
+}
+function validateObservationAttachments(validation) {
+    const { observationAttrs, mageEvent } = validation;
+    const attachments = observationAttrs.attachments;
+    attachments.forEach((x, index) => {
+        const invalid = validateAttachment(x, observationAttrs, mageEvent);
+        if (invalid) {
+            validation.setAttachmentError(index, invalid);
+        }
+    });
+    return validation;
+}
+function validateAttachment(attachment, observation, mageEvent) {
+    const formEntry = formEntryForId(attachment.observationFormId, observation);
+    if (!formEntry) {
+        return new AttachmentValidationError(AttachmentValidationErrorReason.FormEntryRef, `The attachment form entry reference ${attachment.observationFormId} is invalid.`);
+    }
+    const field = mageEvent.formFieldFor(attachment.fieldName, formEntry.formId);
+    if (!field || field.type !== entities_events_forms_1.FormFieldType.Attachment) {
+        return new AttachmentValidationError(AttachmentValidationErrorReason.FieldRef, `The attachment field reference ${attachment.fieldName} is invalid.`);
+    }
+    const dup = observation.attachments.find(x => x.id === attachment.id && x !== attachment);
+    if (dup) {
+        return new AttachmentValidationError(AttachmentValidationErrorReason.DuplicateId, `The attachment ID ${attachment.id} is not unique on the observation.`);
+    }
+    return null;
+}
+function FormFieldValidationResult(context) {
+    return {
+        failedBecauseTheEntry(reason, constraint = FieldConstraintKey.Value) {
+            return new FormFieldValidationError({ fieldName: context.field.name, message: `${context.field.title} ${reason}`, constraint: constraint });
+        },
+        succeeded(parsed) { return parsed; }
+    };
+}
+function validateRequiredThen(rule) {
+    return context => {
+        const requiredError = fields.required.RequiredFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context));
+        if (requiredError) {
+            return requiredError;
+        }
+        return rule(context);
+    };
+}
+// TODO: these could be improved to be more cleanly comosable in a functional way, e.g., monadic. i'll figure that out eventually
+const FieldTypeValidationRules = {
+    // attachments use min/max constraints, not required constraint
+    [entities_events_forms_1.FormFieldType.Attachment]: context => fields.attachment.AttachmentFieldValidation(context.field, context.formEntry.id, context.observationAttrs, FormFieldValidationResult(context)),
+    [entities_events_forms_1.FormFieldType.CheckBox]: validateRequiredThen(context => fields.checkbox.CheckboxFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.DateTime]: validateRequiredThen(context => fields.date.DateFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Dropdown]: validateRequiredThen(context => fields.select.SelectFormFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Email]: validateRequiredThen(context => fields.email.EmailFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Geometry]: validateRequiredThen(context => fields.geometry.GeometryFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    // TODO: no validation at all? legacy validation code did nothing for hidden fields
+    [entities_events_forms_1.FormFieldType.Hidden]: context => null,
+    [entities_events_forms_1.FormFieldType.MultiSelectDropdown]: validateRequiredThen(context => fields.multiselect.MultiSelectFormFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Numeric]: validateRequiredThen(context => fields.numeric.NumericFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Password]: validateRequiredThen(context => fields.text.TextFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Radio]: validateRequiredThen(context => fields.select.SelectFormFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.Text]: validateRequiredThen(context => fields.text.TextFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+    [entities_events_forms_1.FormFieldType.TextArea]: validateRequiredThen(context => fields.text.TextFieldValidation(context.field, context.fieldEntry, FormFieldValidationResult(context))),
+};
+/**
+ * TODO: This retains legacy functionality of only keying of form fields in the
+ * event form to validate the values in the form entry.  However, this leaves
+ * keys in the form entry that do not have a corresponding form field.  A
+ * client could thus submit an observation with thousands of keys in a fomr
+ * entry.
+ */
+function validateFormFieldEntries(formEntry, form, formEntryError, validation) {
+    const { mageEvent, observationAttrs } = validation;
+    const formFields = form.fields || [];
+    const activeFields = formFields.filter(x => !x.archived);
+    activeFields.forEach(field => {
+        const fieldEntry = formEntry[field.name];
+        const fieldValidation = { field, fieldEntry, formEntry, mageEvent, observationAttrs };
+        const resultEntry = FieldTypeValidationRules[field.type](fieldValidation);
+        if (resultEntry instanceof FormFieldValidationError) {
+            formEntryError.addFieldError(resultEntry);
+        }
+        else if (resultEntry !== void (0)) {
+            formEntry[field.name] = resultEntry;
+        }
+    });
+}
+class ObservationValidationContext {
+    constructor(...args) {
+        _ObservationValidationContext_coreAttrsErrors.set(this, void 0);
+        _ObservationValidationContext_formCountErrors.set(this, void 0);
+        _ObservationValidationContext_formEntryErrors.set(this, void 0);
+        _ObservationValidationContext_attachmentErrors.set(this, void 0);
+        _ObservationValidationContext_totalFormCountError.set(this, null);
+        const [fromOrAttrs, maybeMageEvent] = args;
+        if (fromOrAttrs instanceof ObservationValidationContext) {
+            this.observationAttrs = fromOrAttrs.observationAttrs;
+            this.mageEvent = fromOrAttrs.mageEvent;
+            __classPrivateFieldSet(this, _ObservationValidationContext_coreAttrsErrors, new Map(fromOrAttrs.coreAttrsErrors), "f");
+            __classPrivateFieldSet(this, _ObservationValidationContext_formEntryErrors, new Map(fromOrAttrs.formEntryErrors), "f");
+            __classPrivateFieldSet(this, _ObservationValidationContext_formCountErrors, new Map(fromOrAttrs.formCountErrors), "f");
+            __classPrivateFieldSet(this, _ObservationValidationContext_attachmentErrors, new Map(fromOrAttrs.attachmentErrors), "f");
+        }
+        else {
+            this.observationAttrs = fromOrAttrs;
+            this.mageEvent = maybeMageEvent;
+            __classPrivateFieldSet(this, _ObservationValidationContext_coreAttrsErrors, new Map(), "f");
+            __classPrivateFieldSet(this, _ObservationValidationContext_formEntryErrors, new Map(), "f");
+            __classPrivateFieldSet(this, _ObservationValidationContext_formCountErrors, new Map(), "f");
+            __classPrivateFieldSet(this, _ObservationValidationContext_attachmentErrors, new Map(), "f");
+        }
+    }
+    addCoreAttrsError(key, message) {
+        __classPrivateFieldGet(this, _ObservationValidationContext_coreAttrsErrors, "f").set(key, message);
+        return this;
+    }
+    setTotalFormCountError(x) {
+        __classPrivateFieldSet(this, _ObservationValidationContext_totalFormCountError, x, "f");
+        return this;
+    }
+    addFormCountError(x) {
+        __classPrivateFieldGet(this, _ObservationValidationContext_formCountErrors, "f").set(x.formId, x);
+        return this;
+    }
+    addFormEntryError(formEntryError) {
+        __classPrivateFieldGet(this, _ObservationValidationContext_formEntryErrors, "f").set(formEntryError.formEntryPosition, formEntryError);
+        return this;
+    }
+    setAttachmentError(index, err) {
+        __classPrivateFieldGet(this, _ObservationValidationContext_attachmentErrors, "f").set(index, err);
+        return this;
+    }
+    get coreAttrsErrors() {
+        return new Map(__classPrivateFieldGet(this, _ObservationValidationContext_coreAttrsErrors, "f"));
+    }
+    get formCountErrors() {
+        return new Map(__classPrivateFieldGet(this, _ObservationValidationContext_formCountErrors, "f"));
+    }
+    get formEntryErrors() {
+        return new Map(__classPrivateFieldGet(this, _ObservationValidationContext_formEntryErrors, "f"));
+    }
+    get attachmentErrors() {
+        return new Map(__classPrivateFieldGet(this, _ObservationValidationContext_attachmentErrors, "f"));
+    }
+    get totalFormCountError() {
+        return __classPrivateFieldGet(this, _ObservationValidationContext_totalFormCountError, "f");
+    }
+    get hasErrors() {
+        return __classPrivateFieldGet(this, _ObservationValidationContext_coreAttrsErrors, "f").size > 0
+            || __classPrivateFieldGet(this, _ObservationValidationContext_totalFormCountError, "f") !== null
+            || __classPrivateFieldGet(this, _ObservationValidationContext_formCountErrors, "f").size > 0
+            || __classPrivateFieldGet(this, _ObservationValidationContext_formEntryErrors, "f").size > 0
+            || __classPrivateFieldGet(this, _ObservationValidationContext_attachmentErrors, "f").size > 0;
+    }
+    result() {
+        const hasErrors = this.hasErrors;
+        const coreAttrsErrors = Object.freeze(Object.fromEntries(this.coreAttrsErrors));
+        const totalFormCountError = this.totalFormCountError;
+        const formCountErrors = Object.freeze(Array.from(this.formCountErrors.entries()));
+        const formEntryErrors = Object.freeze(Array.from(this.formEntryErrors.entries()));
+        const attachmentErrors = Object.freeze(Array.from(this.attachmentErrors.entries()));
+        return Object.freeze({
+            hasErrors,
+            coreAttrsErrors,
+            totalFormCountError,
+            formCountErrors,
+            formEntryErrors,
+            attachmentErrors,
+        });
+    }
+}
+_ObservationValidationContext_coreAttrsErrors = new WeakMap(), _ObservationValidationContext_formCountErrors = new WeakMap(), _ObservationValidationContext_formEntryErrors = new WeakMap(), _ObservationValidationContext_attachmentErrors = new WeakMap(), _ObservationValidationContext_totalFormCountError = new WeakMap();
+function AttachmentsRemovedDomainEvent(observation, removedAttachments) {
+    return Object.freeze({
+        type: ObservationDomainEventType.AttachmentsRemoved,
+        removedAttachments: Object.freeze(removedAttachments)
+    });
+}
+function mergePendingDomainEvents(from, nextEvents) {
+    const removedAttachments = [];
+    const merged = [...from.pendingEvents, ...nextEvents].reduce((merged, e) => {
+        if (e.type === ObservationDomainEventType.AttachmentsRemoved) {
+            removedAttachments.push(...e.removedAttachments);
+            return merged;
+        }
+        else {
+            return [...merged, e];
+        }
+    }, []);
+    if (removedAttachments.length) {
+        merged.push(AttachmentsRemovedDomainEvent(from, removedAttachments));
+    }
+    return merged;
+}
+//# sourceMappingURL=entities.observations.js.map