Update Dockerfile

Update invite link to use the new domain

.gitignore

@@ -0,0 +1 @@
+build

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "app/packages/redis-oplog"]
+	path = app/packages/redis-oplog
+	url = https://github.com/ramezrafla/redis-oplog.git

.vscode/launch.json

@@ -0,0 +1,17 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Meteor: Test",
+      "type": "node",
+      "request": "launch",
+      "cwd": "${workspaceFolder}/app",
+      "runtimeExecutable": "npm",
+      "runtimeArgs": [
+        "run-script",
+        "test"
+      ],
+      "outputCapture": "std",
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,50 @@
+{
+  "cSpell.words": [
+    "alea",
+    "armor",
+    "autorun",
+    "blackbox",
+    "cantrip",
+    "Cantrips",
+    "Crit",
+    "Crits",
+    "cyrb",
+    "denormalize",
+    "denormalized",
+    "EJSON",
+    "healthbar",
+    "healthbars",
+    "Hitpoints",
+    "jank",
+    "meteortesting",
+    "multigraph",
+    "nearley",
+    "ngraph",
+    "nonreactive",
+    "ostrio",
+    "pather",
+    "recomputation",
+    "Ruleset",
+    "snackbars",
+    "Spellcasting",
+    "Subheaders",
+    "thumbhash",
+    "uncomputed",
+    "untarget",
+    "vars",
+    "vuedraggable",
+    "vuetify",
+    "Vuex",
+    "walkdown"
+  ],
+  "javascript.preferences.importModuleSpecifier": "non-relative",
+  "javascript.preferences.importModuleSpecifierEnding": "minimal",
+  "javascript.preferences.organizeImports": {
+    "enabled": true,
+  },
+  "typescript.preferences.importModuleSpecifier": "non-relative",
+  "typescript.preferences.importModuleSpecifierEnding": "minimal",
+  "typescript.preferences.organizeImports": {
+    "enabled": true,
+  }
+}

Dockerfile

@@ -1,14 +1,29 @@
-FROM ubuntu:latest
-RUN apt-get update --quiet \
-    && apt-get install --quiet --yes \
-    bsdtar \
-    curl \
-    git
-RUN ln --symbolic --force $(which bsdtar) $(which tar)
-RUN useradd --create-home --shell /bin/bash dicecloud
-USER dicecloud
-WORKDIR /home/dicecloud
-RUN curl https://install.meteor.com/?release=1.8.0.2 | sh
-ENV PATH="${PATH}:/home/dicecloud/.meteor"
-COPY dev.sh ./dev.sh
-ENTRYPOINT ./dev.sh
+FROM ubuntu:jammy
+
+USER root
+RUN adduser --system mt
+
+RUN apt-get update && apt-get install -y ca-certificates curl gnupg git
+RUN mkdir -p /etc/apt/keyrings
+RUN curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key \
+  | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
+RUN echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" \
+  > /etc/apt/sources.list.d/nodesource.list
+RUN apt-get update && apt-get install -y nodejs
+
+USER mt
+
+RUN curl https://install.meteor.com/ | sh
+
+WORKDIR /home/mt
+RUN git clone https://github.com/ThaumRystra/DiceCloud dicecloud
+WORKDIR /home/mt/dicecloud/app
+RUN npm install --production
+ENV PATH=$PATH:/home/mt/.meteor
+RUN meteor build --directory ~/dc/ --architecture os.linux.x86_64
+WORKDIR /home/mt/dc/bundle/programs/server
+RUN npm install
+WORKDIR /home/mt/dc/bundle
+RUN rm -r /home/mt/dicecloud
+
+ENTRYPOINT node main.js

README.md

@@ -1,7 +1,7 @@
 DiceCloud
 ========
 
-This is the repo for [DiceCloud](dicecloud.com).
+This is the repo for [DiceCloud](https://dicecloud.com).
 
 DiceCloud is a free, auditable, real-time character sheet for D&D 5e.
 
@@ -78,8 +78,12 @@ NPM_CONFIG_PRODUCTION=true
 PROJECT_DIR=app
 ROOT_URL=https://<url of your DiceCloud instance>
 DEFAULT_LIBRARIES=<comma separated list of library ids that will be subscribed by default: "abc123,def456">
-DISABLE_PATREON=<"true" if you want to prevent features being locked behind Patreon tiers>
 ```
 
+To disable Patreon features and unlock all paid restrictions for all users of your deployment, replace
+`"patreon": { "clientId": ... }"` with `"disablePatreon": true` in the public key of the METEOR_SETTINGS environment variable.
+
+Alternatively run `meteor run --settings exampleMeteorSettings.json` to start the app with the example settings that disable Patreon by default.
+
 Now, visiting [](http://localhost:3000/) should show you an empty instance of
 DiceCloud running.

app/.gitignore

@@ -2,6 +2,11 @@
 .meteor/meteorite
 .demeteorized
 .cache
+.vscode
+.coverage
+.nyc_output
+.DS_Store
+fileStorage
 settings.json
 public/components
 public/_imports.html
@@ -9,3 +14,4 @@ private/oldClient
 nohup.out
 node_modules
 dump
+*.crt

app/.meteor/packages

@@ -3,44 +3,31 @@
 # 'meteor add' and 'meteor remove' will edit this file for you,
 # but you can also edit it by hand.
 
-accounts-password
-random
-dburles:collection-helpers
-reactive-var
-underscore
-momentjs:moment
+accounts-password@2.4.0
+random@1.2.1
+underscore@1.6.1
 dburles:mongo-collection-instances
-accounts-google
-email
-meteorhacks:subs-manager
-chuangbo:marked
-meteor-base
-mobile-experience
-mongo
-session
-tracker
-logging
-reload
-ejson
-check
-standard-minifier-js
-shell-server
-templates:array
-ecmascript
-es5-shim
-reactive-dict
-percolate:synced-cron
-ongoworks:speakingurl
-service-configuration
-dynamic-import
-ddp-rate-limiter
-rate-limit
+accounts-google@1.4.0
+email@2.2.6
+meteor-base@1.5.1
+mobile-experience@1.1.1
+mongo@1.16.10
+session@1.2.1
+tracker@1.3.3
+logging@1.3.4
+reload@1.3.1
+ejson@1.1.3
+check@1.4.1
+standard-minifier-js@2.8.1
+shell-server@0.5.0
+service-configuration@1.3.4
+dynamic-import@0.7.3
+ddp-rate-limiter@1.2.1
+rate-limit@1.1.1
 mdg:validated-method
-akryum:vue-router2
-static-html
+static-html@1.3.2
 aldeed:collection2
 aldeed:schema-index
-zer0th:meteor-vuetify-loader
 accounts-patreon
 bozhao:link-accounts
 peerlibrary:reactive-publish
@@ -48,6 +35,21 @@ simple:rest
 simple:rest-method-mixin
 mikowals:batch-insert
 peerlibrary:subscription-data
+zer0th:meteor-vuetify-loader
+akryum:vue-component@0.15.2
+akryum:vue-router2
+percolate:migrations
+meteortesting:mocha
+ostrio:files
+simple:rest-bearer-token-parser
+simple:rest-json-error-handler
+littledata:synced-cron
+#mdg:meteor-apm-agent
 seba:minifiers-autoprefixer
-akryum:vue-component
-akryum:vue-sass
+#mixmax:smart-disconnect
+zodern:types
+zodern:fix-async-stubs
+typescript@4.9.5
+ecmascript@0.16.8
+lmieulet:meteor-legacy-coverage
+lmieulet:meteor-coverage

app/.meteor/release

@@ -1 +1 @@
-METEOR@2.2.1
+METEOR@2.16

app/.meteor/versions

@@ -1,87 +1,86 @@
-accounts-base@1.9.0
-accounts-google@1.3.3
-accounts-oauth@1.2.0
-accounts-password@1.7.1
+accounts-base@2.2.11
+accounts-google@1.4.0
+accounts-oauth@1.4.4
+accounts-password@2.4.0
 accounts-patreon@0.1.0
 akryum:npm-check@0.1.2
-akryum:vue-component@0.15.2
+akryum:vue-component@0.16.0
 akryum:vue-component-dev-client@0.4.7
 akryum:vue-component-dev-server@0.1.4
 akryum:vue-router2@0.2.3
-akryum:vue-sass@0.1.2
-aldeed:collection2@3.4.1
-aldeed:schema-index@3.0.0
-allow-deny@1.1.0
-autoupdate@1.7.0
-babel-compiler@7.6.2
-babel-runtime@1.5.0
+aldeed:collection2@3.5.0
+aldeed:schema-index@3.1.0
+allow-deny@1.1.1
+autoupdate@1.8.0
+babel-compiler@7.10.5
+babel-runtime@1.5.1
 base64@1.0.12
 binary-heap@1.0.11
-blaze-tools@1.1.2
-boilerplate-generator@1.7.1
-bozhao:link-accounts@2.4.0
+blaze-tools@1.1.4
+boilerplate-generator@1.7.2
+bozhao:link-accounts@2.8.0
 caching-compiler@1.2.2
-caching-html-compiler@1.2.1
-callback-hook@1.3.0
-check@1.3.1
-chuangbo:marked@0.3.5_1
-coffeescript@2.4.1
+caching-html-compiler@1.2.2
+callback-hook@1.5.1
+check@1.4.1
+coffeescript@2.7.0
 coffeescript-compiler@2.4.1
-dburles:collection-helpers@1.1.0
-dburles:mongo-collection-instances@0.3.5
-ddp@1.4.0
-ddp-client@2.4.1
-ddp-common@1.4.0
-ddp-rate-limiter@1.0.9
-ddp-server@2.3.3
-deps@1.0.12
-diff-sequence@1.1.1
-dynamic-import@0.6.0
-ecmascript@0.15.1
-ecmascript-runtime@0.7.0
-ecmascript-runtime-client@0.11.1
-ecmascript-runtime-server@0.10.1
-ejson@1.1.1
-email@2.0.0
+dburles:mongo-collection-instances@0.4.0
+ddp@1.4.1
+ddp-client@2.6.2
+ddp-common@1.4.1
+ddp-rate-limiter@1.2.1
+ddp-server@2.7.1
+diff-sequence@1.1.2
+dynamic-import@0.7.3
+ecmascript@0.16.8
+ecmascript-runtime@0.8.1
+ecmascript-runtime-client@0.12.1
+ecmascript-runtime-server@0.11.0
+ejson@1.1.3
+email@2.2.6
 es5-shim@4.8.0
-fetch@0.1.1
-geojson-utils@1.0.10
-google-oauth@1.3.0
+fetch@0.1.4
+geojson-utils@1.0.11
+google-oauth@1.4.4
 hot-code-push@1.0.4
-html-tools@1.1.2
-htmljs@1.1.1
-http@1.4.4
+html-tools@1.1.4
+htmljs@1.2.1
+http@2.0.0
 id-map@1.1.1
 inter-process-messaging@0.1.1
-lai:collection-extensions@0.2.1_1
-launch-screen@1.2.1
-livedata@1.0.18
+lai:collection-extensions@0.4.0
+launch-screen@2.0.0
+littledata:synced-cron@1.5.1
+lmieulet:meteor-coverage@4.1.0
+lmieulet:meteor-legacy-coverage@0.2.0
 localstorage@1.2.0
-logging@1.2.0
-mdg:validated-method@1.2.0
-meteor@1.9.3
-meteor-base@1.4.0
-meteorhacks:subs-manager@1.6.4
-mikowals:batch-insert@1.2.0
-minifier-css@1.5.4
-minifier-js@2.6.1
-minimongo@1.6.2
-mobile-experience@1.1.0
+logging@1.3.4
+mdg:validated-method@1.3.0
+meteor@1.11.5
+meteor-base@1.5.1
+meteortesting:browser-tests@1.5.3
+meteortesting:mocha@2.1.0
+meteortesting:mocha-core@8.1.2
+mikowals:batch-insert@1.3.0
+minifier-css@1.6.4
+minifier-js@2.8.0
+minimongo@1.9.4
+mobile-experience@1.1.1
 mobile-status-bar@1.1.0
-modern-browsers@0.1.5
-modules@0.16.0
-modules-runtime@0.12.0
-momentjs:moment@2.29.1
-mongo@1.11.1
-mongo-decimal@0.1.2
+modern-browsers@0.1.10
+modules@0.20.0
+modules-runtime@0.13.1
+mongo@1.16.10
+mongo-decimal@0.1.3
 mongo-dev-server@1.1.0
 mongo-id@1.0.8
-npm-bcrypt@0.9.4
-npm-mongo@3.9.0
-oauth@1.3.2
-oauth2@1.3.0
-ongoworks:speakingurl@9.0.0
+npm-mongo@4.17.2
+oauth@2.2.1
+oauth2@1.3.2
 ordered-dict@1.1.0
+ostrio:cookies@2.8.1
+ostrio:files@2.3.3
 patreon-oauth@0.1.0
 peerlibrary:assert@0.3.0
 peerlibrary:check-extension@0.7.0
@@ -89,41 +88,43 @@ peerlibrary:computed-field@0.10.0
 peerlibrary:data-lookup@0.3.0
 peerlibrary:extend-publish@0.6.0
 peerlibrary:fiber-utils@0.10.0
-peerlibrary:reactive-mongo@0.4.0
+peerlibrary:reactive-mongo@0.4.1
 peerlibrary:reactive-publish@0.10.0
 peerlibrary:server-autorun@0.8.0
 peerlibrary:subscription-data@0.8.0
-percolate:synced-cron@1.3.2
-promise@0.11.2
+percolate:migrations@1.1.1
+promise@0.12.2
 raix:eventemitter@1.0.0
-random@1.2.0
-rate-limit@1.0.9
-react-fast-refresh@0.1.1
-reactive-dict@1.3.0
-reactive-var@1.0.11
+random@1.2.1
+rate-limit@1.1.1
+react-fast-refresh@0.2.8
+reactive-dict@1.3.1
+reactive-var@1.0.12
 reload@1.3.1
 retry@1.1.0
-routepolicy@1.1.0
+routepolicy@1.1.1
 seba:minifiers-autoprefixer@2.0.1
-service-configuration@1.0.11
-session@1.2.0
+service-configuration@1.3.4
+session@1.2.1
 sha@1.0.9
 shell-server@0.5.0
-simple:json-routes@2.1.0
-simple:rest@1.1.1
-simple:rest-method-mixin@1.0.1
-socket-stream-client@0.3.3
-spacebars-compiler@1.3.0
-srp@1.1.0
-standard-minifier-js@2.6.1
+simple:json-routes@2.3.1
+simple:rest@1.2.1
+simple:rest-bearer-token-parser@1.1.1
+simple:rest-json-error-handler@1.1.3
+simple:rest-method-mixin@1.1.0
+socket-stream-client@0.5.2
+spacebars-compiler@1.3.2
+standard-minifier-js@2.8.1
 static-html@1.3.2
-templates:array@1.0.3
-templating-tools@1.2.1
+templating-tools@1.2.3
 tmeasday:check-npm-versions@1.0.2
-tracker@1.2.0
-typescript@4.2.2
-underscore@1.0.10
+tracker@1.3.3
+typescript@4.9.5
+underscore@1.6.1
 url@1.3.2
-webapp@1.10.1
-webapp-hashing@1.1.0
-zer0th:meteor-vuetify-loader@0.1.30
+webapp@1.13.8
+webapp-hashing@1.1.1
+zer0th:meteor-vuetify-loader@0.1.41
+zodern:fix-async-stubs@1.0.2
+zodern:types@1.0.13

app/client/head.html

@@ -2,38 +2,38 @@
   <link href="https://fonts.googleapis.com/css?family=Roboto:100,300,400,500,700,900" rel="stylesheet">
   <link href="https://cdn.jsdelivr.net/npm/@mdi/font@5.x/css/materialdesignicons.min.css" rel="stylesheet">
   <meta name="viewport" content="width=device-width initial-scale=1.0, user-scalable=no">
-	<meta name="mobile-web-app-capable" content="yes">
-	<meta name="apple-mobile-web-app-capable" content="yes">
-	<link rel="apple-touch-icon" sizes="57x57" href="/apple-touch-icon-57x57.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="60x60" href="/apple-touch-icon-60x60.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="72x72" href="/apple-touch-icon-72x72.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="76x76" href="/apple-touch-icon-76x76.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="114x114" href="/apple-touch-icon-114x114.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="120x120" href="/apple-touch-icon-120x120.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="144x144" href="/apple-touch-icon-144x144.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="152x152" href="/apple-touch-icon-152x152.png?v=lk6WXp6Pmj">
-	<link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png?v=lk6WXp6Pmj">
-	<link rel="icon" type="image/png" href="/favicon-32x32.png?v=lk6WXp6Pmj" sizes="32x32">
-	<link rel="icon" type="image/png" href="/favicon-194x194.png?v=lk6WXp6Pmj" sizes="194x194">
-	<link rel="icon" type="image/png" href="/favicon-96x96.png?v=lk6WXp6Pmj" sizes="96x96">
-	<link rel="icon" type="image/png" href="/android-chrome-192x192.png?v=lk6WXp6Pmj" sizes="192x192">
-	<link rel="icon" type="image/png" href="/favicon-16x16.png?v=lk6WXp6Pmj" sizes="16x16">
-	<link rel="manifest" href="/manifest.json?v=lk6WXp6Pmj">
-	<link rel="shortcut icon" href="/favicon.ico?v=lk6WXp6Pmj">
-	<meta name="msapplication-TileColor" content="#b91d1d">
-	<meta name="msapplication-TileImage" content="/mstile-144x144.png?v=lk6WXp6Pmj">
-	<meta name="theme-color" content="#d12929">
+  <meta name="mobile-web-app-capable" content="yes">
+  <meta name="apple-mobile-web-app-capable" content="yes">
+  <link rel="apple-touch-icon" sizes="57x57" href="/apple-touch-icon-57x57.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="60x60" href="/apple-touch-icon-60x60.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="72x72" href="/apple-touch-icon-72x72.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="76x76" href="/apple-touch-icon-76x76.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="114x114" href="/apple-touch-icon-114x114.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="120x120" href="/apple-touch-icon-120x120.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="144x144" href="/apple-touch-icon-144x144.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="152x152" href="/apple-touch-icon-152x152.png?v=lk6WXp6Pmj">
+  <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon-180x180.png?v=lk6WXp6Pmj">
+  <link rel="icon" type="image/png" href="/favicon-32x32.png?v=lk6WXp6Pmj" sizes="32x32">
+  <link rel="icon" type="image/png" href="/favicon-194x194.png?v=lk6WXp6Pmj" sizes="194x194">
+  <link rel="icon" type="image/png" href="/favicon-96x96.png?v=lk6WXp6Pmj" sizes="96x96">
+  <link rel="icon" type="image/png" href="/android-chrome-192x192.png?v=lk6WXp6Pmj" sizes="192x192">
+  <link rel="icon" type="image/png" href="/favicon-16x16.png?v=lk6WXp6Pmj" sizes="16x16">
+  <link rel="manifest" href="/manifest.json?v=lk6WXp6Pmj">
+  <link rel="shortcut icon" href="/favicon.ico?v=lk6WXp6Pmj">
+  <meta name="msapplication-TileColor" content="#b91d1d">
+  <meta name="msapplication-TileImage" content="/mstile-144x144.png?v=lk6WXp6Pmj">
+  <meta name="theme-color" content="#d12929">
 
-	<style type="text/css" media="print">
-		@page {
-			margin: 0mm;
-		}
-		html {
-			margin: 0px;
-		}
-		* {
-			-webkit-transition: none !important;
-			transition: none !important;
-		}
-	</style>
+  <style type="text/css" media="print">
+    @page {
+      margin: 0mm;
+    }
+    html {
+      margin: 0px;
+    }
+    * {
+      -webkit-transition: none !important;
+      transition: none !important;
+    }
+  </style>
 </head>

app/client/main.js

@@ -1,3 +1,7 @@
-import '/imports/ui/vueSetup.js';
-import '/imports/ui/styles/stylesIndex.js';
-import '/imports/client/config.js';
+import '/imports/api/simpleSchemaConfig';
+import '/imports/client/ui/vueSetup';
+import '/imports/client/ui/styles/stylesIndex';
+import '/imports/client/config';
+import '/imports/client/serviceWorker';
+
+import 'ngraph.graph';

app/exampleMeteorSettings.json

@@ -0,0 +1,7 @@
+{
+  "public": {
+    "environment": "production",
+    "disablePatreon": true,
+    "disallowCreatureApiImport": false
+  }
+}

app/imports/@types/ddp-rate-limiter-mixin.d.ts

@@ -0,0 +1,3 @@
+declare module 'ddp-rate-limiter-mixin' {
+  export const RateLimiterMixin: <T>(options: T) => T;
+}

app/imports/@types/ddp.d.ts

@@ -0,0 +1,3 @@
+declare namespace DDP {
+  function randomStream(seed: string): typeof Random;
+}

app/imports/@types/meteor-ostrio-files.d.ts

@@ -0,0 +1,244 @@
+declare module 'meteor/ostrio:files' {
+  import { Meteor } from 'meteor/meteor';
+  import { Mongo } from 'meteor/mongo';
+  import { ReactiveVar } from 'meteor/reactive-var';
+  import { SimpleSchemaDefinition } from 'simpl-schema';
+  import * as http from 'http';
+  import { IncomingMessage } from 'connect';
+
+  interface Params {
+    _id: string;
+    query: { [key: string]: string };
+    name: string;
+    version: string;
+  }
+
+  interface ContextHTTP {
+    request: IncomingMessage;
+    response: http.ServerResponse;
+    params: Params;
+  }
+
+  interface ContextUser {
+    userId: string;
+    user: () => Meteor.User;
+  }
+
+  interface ContextUpload {
+    file: object;
+    /** On server only. */
+    chunkId?: number;
+    /** On server only. */
+    eof?: boolean;
+  }
+
+  interface Version<MetadataType> {
+    extension: string;
+    meta: MetadataType;
+    path: string;
+    size: number;
+    type: string;
+  }
+
+  class FileObj<MetadataType> {
+    _id: string;
+    size: number;
+    name: string;
+    type: string;
+    path: string;
+    isVideo: boolean;
+    isAudio: boolean;
+    isImage: boolean;
+    isText: boolean;
+    isJSON: boolean;
+    isPDF: boolean;
+    ext?: string;
+    extension?: string;
+    extensionWithDot: string;
+    _storagePath: string;
+    _downloadRoute: string;
+    _collectionName: string;
+    public?: boolean;
+    meta?: MetadataType;
+    userId?: string;
+    updatedAt?: Date;
+    versions: {
+      [propName: string]: Version<MetadataType>;
+    };
+    mime: string;
+    'mime-type': string;
+  }
+
+  class FileRef<MetadataType> extends FileObj<MetadataType> {
+    remove: (callback?: (error: Meteor.Error) => void) => void;
+    link: (version?: string, location?: string) => string;
+    get: (property?: string) => any;
+    fetch: () => Array<FileObj<MetadataType>>;
+    with: () => FileCursor<MetadataType>;
+  }
+
+  interface FileData<MetadataType> {
+    size: number;
+    type: string;
+    mime: string;
+    'mime-type': string;
+    ext: string;
+    extension: string;
+    name: string;
+    meta: MetadataType;
+  }
+
+  interface FilesCollectionConfig<MetadataType> {
+    storagePath?: string | ((fileObj: FileObj<MetadataType>) => string);
+    collection?: Mongo.Collection<FileObj<MetadataType>>;
+    collectionName?: string;
+    continueUploadTTL?: string;
+    ddp?: object;
+    cacheControl?: string;
+    responseHeaders?: { [x: string]: string } | ((responseCode?: string, fileRef?: FileRef<MetadataType>, versionRef?: Version<MetadataType>, version?: string) => { [x: string]: string });
+    throttle?: number | boolean;
+    downloadRoute?: string;
+    schema?: SimpleSchemaDefinition;
+    chunkSize?: number;
+    namingFunction?: (fileObj: FileObj<MetadataType>) => string;
+    permissions?: number;
+    parentDirPermissions?: number;
+    integrityCheck?: boolean;
+    strict?: boolean;
+    downloadCallback?: (this: ContextHTTP & ContextUser, fileObj: FileObj<MetadataType>) => boolean;
+    protected?: boolean | ((this: ContextHTTP & ContextUser, fileObj: FileObj<MetadataType>) => boolean | number);
+    public?: boolean;
+    onBeforeUpload?: (this: ContextUpload & ContextUser, fileData: FileData<MetadataType>) => boolean | string;
+    onBeforeRemove?: (this: ContextUser, cursor: Mongo.Cursor<FileObj<MetadataType>>) => boolean;
+    onInitiateUpload?: (this: ContextUpload & ContextUser, fileData: FileData<MetadataType>) => void;
+    onAfterUpload?: (fileRef: FileRef<MetadataType>) => any;
+    onAfterRemove?: (files: ReadonlyArray<FileObj<MetadataType>>) => any;
+    onbeforeunloadMessage?: string | (() => string);
+    allowClientCode?: boolean;
+    debug?: boolean;
+    interceptDownload?: (http: object, fileRef: FileRef<MetadataType>, version: string) => boolean;
+  }
+
+  interface SearchOptions<MetadataType, TransformAdditions> {
+    sort?: Mongo.SortSpecifier;
+    skip?: number;
+    limit?: number;
+    fields?: Mongo.FieldSpecifier;
+    reactive?: boolean;
+    transform?: (fileObj: FileObj<MetadataType>) => FileObj<MetadataType> & TransformAdditions;
+  }
+
+  interface InsertOptions<MetadataType> {
+    file: File | object | string;
+    fileId?: string;
+    fileName?: string;
+    isBase64?: boolean;
+    meta?: MetadataType;
+    transport?: 'ddp' | 'http';
+    ddp?: object;
+    onStart?: (error: Meteor.Error, fileData: FileData<MetadataType>) => any;
+    onUploaded?: (error: Meteor.Error, fileRef: FileRef<MetadataType>) => any;
+    onAbort?: (fileData: FileData<MetadataType>) => any;
+    onError?: (error: Meteor.Error, fileData: FileData<MetadataType>) => any;
+    onProgress?: (progress: number, fileData: FileData<MetadataType>) => any;
+    onBeforeUpload?: (fileData: FileData<MetadataType>) => any;
+    chunkSize?: number | 'dynamic';
+    allowWebWorkers?: boolean;
+    type?: string;
+  }
+
+  interface LoadOptions<MetadataType> {
+    fileName: string;
+    meta?: MetadataType;
+    type?: string;
+    size?: number;
+    userId?: string;
+    fileId?: string;
+  }
+
+  class FileUpload {
+    file: File;
+    onPause: ReactiveVar<boolean>;
+    progress: ReactiveVar<number>;
+    estimateTime: ReactiveVar<number>;
+    estimateSpeed: ReactiveVar<number>;
+    state: ReactiveVar<'active' | 'paused' | 'aborted' | 'completed'>;
+    pause(): void;
+    continue(): void;
+    toggle(): void;
+    pipe(): void;
+    start(): void;
+    on(event: string, callback: () => void): void;
+  }
+
+  class FileCursor<MetadataType> extends FileRef<MetadataType> { }
+
+  class FilesCursor<MetadataType, TransformAdditions> extends Mongo.Cursor<FileObj<MetadataType>> {
+    cursor: Mongo.Cursor<FileObj<MetadataType>>; // Refers to base cursor? Why is this existing?
+
+    get(): Array<FileCursor<MetadataType> & TransformAdditions>;
+    hasNext(): boolean;
+    next(): FileCursor<MetadataType> & TransformAdditions;
+    hasPrevious(): boolean;
+    previous(): FileCursor<MetadataType> & TransformAdditions;
+    first(): FileCursor<MetadataType> & TransformAdditions;
+    last(): FileCursor<MetadataType> & TransformAdditions;
+    remove(callback?: (err: object) => void): void;
+    each(callback: (cursor: FileCursor<MetadataType> & TransformAdditions) => void): void;
+    current(): object | undefined;
+  }
+
+  class FilesCollection<MetadataType = { [x: string]: any }> {
+    collection: Mongo.Collection<FileObj<MetadataType>>;
+    schema: SimpleSchemaDefinition;
+
+    constructor(config: FilesCollectionConfig<MetadataType>)
+
+    /**
+     * Find and return Cursor for matching documents.
+     *
+     * @param selector [[http://docs.meteor.com/api/collections.html#selectors | Mongo-Style selector]]
+     * @param options [[http://docs.meteor.com/api/collections.html#sortspecifiers | Mongo-Style selector Options]]
+     *
+     * @template TransformAdditions Additional properties provided by transforming a document with options.tranform().
+     *                        Note that removing fields with a transform function is not currently supported as this may break
+     *                        functions defined on a FileRef or FileCursor.
+     */
+    find<TransformAdditions = {}>(
+      selector?: Mongo.Selector<Partial<FileObj<MetadataType>>>,
+      options?: SearchOptions<MetadataType, TransformAdditions>
+    ): FilesCursor<MetadataType, TransformAdditions>;
+
+    /**
+     * Finds the first document that matches the selector, as ordered by sort and skip options.
+     *
+     * @param selector [[http://docs.meteor.com/api/collections.html#selectors | Mongo-Style selector]]
+     * @param options [[http://docs.meteor.com/api/collections.html#sortspecifiers | Mongo-Style selector Options]]
+     *
+     * @template TransformAdditions Additional properties provided by transforming a document with options.tranform().
+     *                        Note that removing fields with a transform function is not currently supported as this may break
+     *                        functions defined on a FileRef or FileCursor.
+     */
+    findOne<TransformAdditions = {}>(
+      selector?: Mongo.Selector<Partial<FileObj<MetadataType>>> | string,
+      options?: SearchOptions<MetadataType, TransformAdditions>
+    ): FileCursor<MetadataType> & TransformAdditions;
+
+    insert(settings: InsertOptions<MetadataType>, autoStart?: boolean): FileUpload;
+    remove(select: Mongo.Selector<FileObj<MetadataType>> | string, callback?: (error: Meteor.Error) => void): FilesCollection<MetadataType>;
+    update(select: Mongo.Selector<FileObj<MetadataType>> | string, modifier: Mongo.Modifier<FileObj<MetadataType>>, options?: {
+      multi?: boolean;
+      upsert?: boolean;
+      arrayFilters?: Array<{ [identifier: string]: any }>;
+    }, callback?: (error: Meteor.Error, insertedCount: number) => void): FilesCollection<MetadataType>;
+    link(fileRef: FileRef<MetadataType>, version?: string): string;
+    allow(options: Mongo.AllowDenyOptions): void;
+    deny(options: Mongo.AllowDenyOptions): void;
+    denyClient(): void;
+    on(event: string, callback: (fileRef: FileRef<MetadataType>) => void): void;
+    unlink(fileRef: FileRef<MetadataType>, version?: string): FilesCollection<MetadataType>;
+    addFile(path: string, opts: LoadOptions<MetadataType>, callback?: (err: any, fileRef: FileRef<MetadataType>) => any, proceedAfterUpload?: boolean): FilesCollection<MetadataType>;
+    load(url: string, opts: LoadOptions<MetadataType>, callback?: (err: object, fileRef: FileRef<MetadataType>) => any, proceedAfterUpload?: boolean): FilesCollection<MetadataType>;
+    write(buffer: Buffer, opts: LoadOptions<MetadataType>, callback?: (err: object, fileRef: FileRef<MetadataType>) => any, proceedAfterUpload?: boolean): FilesCollection<MetadataType>;
+  }
+}

app/imports/@types/meteor.d.ts

@@ -0,0 +1,5 @@
+declare namespace Meteor {
+  interface User {
+    roles?: string[];
+  }
+}

app/imports/@types/mongo.d.ts

@@ -0,0 +1,49 @@
+type SimpleSchema = import('simpl-schema').default;
+type TypedSimpleSchema<T> = import('imports/api/utility/TypedSimpleSchema').TypedSimpleSchema<T>;
+
+declare namespace Mongo {
+  interface CollectionStatic {
+    get: <T>(
+      collectionName: string, options?: { connection: Meteor.Connection }
+    ) => Mongo.Collection<T>;
+  }
+  type SchemaOptions = {
+    /**
+     * Set to `true` if your document must be passed through the collection's transform to properly validate
+     */
+    transform?: boolean,
+    /**
+     * Set to `true` to replace any existing schema instead of combining
+     */
+    replace?: boolean
+    selector?: any;
+  }
+
+  interface Collection<T> {
+    schema: TypedSimpleSchema<T>;
+    simpleSchema<U extends Partial<T>>(selector?: U): TypedSimpleSchema<T & U>;
+    /**
+     * Use this method to attach a schema to a collection created by another package,
+     * such as Meteor.users. It is most likely unsafe to call this method more than
+     * once for a single collection, or to call this for a collection that had a
+     * schema object passed to its constructor.
+     * @param ss SimpleSchema instance or a schema definition object from which to create a new SimpleSchema instance
+     * @param options Options
+     *
+     */
+    attachSchema(ss: SimpleSchema | TypedSimpleSchema<T>, options?: SchemaOptions): void;
+    update(
+      selector: Selector<T> | ObjectID | string,
+      modifier: Modifier<T>,
+      options?: {
+        multi?: boolean | undefined;
+        upsert?: boolean | undefined;
+        arrayFilters?: Array<{ [identifier: string]: any }> | undefined;
+        // Add Collection2 options
+        selector?: Record<string, any>;
+        getAutoValues?: boolean;
+      },
+      callback?: FunctionConstructor,
+    ): number;
+  }
+}

app/imports/@types/validated-method.d.ts

@@ -0,0 +1,27 @@
+declare module 'meteor/mdg:validated-method' {
+  interface ValidatedMethodOptionsMixinFields<TRunArg, TRunReturn> {
+    rateLimit: {
+      numRequests: number,
+      timeInterval: number,
+    };
+  }
+  type Return<TFunc> = TFunc extends (...args: any[]) => infer TReturn ? TReturn : never;
+  type Argument<TFunc> = TFunc extends (...args: infer TArgs) => any ? TArgs extends [infer TArg] ? TArg
+    : NoArguments
+    : never;
+  interface ValidatedMethod<TName extends string, TRun extends (...args: any[]) => any> {
+    callAsync: Argument<TRun> extends NoArguments
+    // methods with no argument can be called with () or just a callback
+    ?
+    & ((unusedArg: any, callback?: (error: Meteor.Error, result: Return<TRun>) => void) => void)
+    & ((callback?: (error: Meteor.Error | undefined, result: Return<TRun>) => void) => void)
+    & (() => Return<TRun>)
+    // methods with arguments require those arguments to be called
+    :
+    & ((
+      arg: Argument<TRun>,
+      callback?: (error: Meteor.Error | undefined, result: Return<TRun>) => void,
+    ) => void)
+    & ((arg: Argument<TRun>) => Return<TRun>);
+  }
+}

app/imports/@types/vue-meteor.d.ts

@@ -0,0 +1,15 @@
+import Vue from 'vue';
+
+declare module 'vue/types/options' {
+  interface ComponentOptions<V extends Vue> {
+    meteor?: any;
+  }
+}
+
+declare module 'vue/types/vue' {
+  interface Vue {
+    $subscribe: (name: string, params: any[]) => void;
+    $autorun: (fn: () => void) => number;
+    $subReady: Record<string, boolean>;
+  }
+}

app/imports/api/creature/actions/applyAction.js

@@ -1,13 +0,0 @@
-import spendResources from '/imports/api/creature/actions/spendResources.js'
-import embedInlineCalculations from '/imports/api/creature/computation/afterComputation/embedInlineCalculations.js';
-
-export default function applyAction({prop, log}){
-  let content = { name: prop.name };
-  if (prop.summary){
-    content.value = embedInlineCalculations(
-      prop.summary, prop.summaryCalculations
-    );
-  }
-  log.content.push(content);
-  spendResources({prop, log});
-}

app/imports/api/creature/actions/applyAdjustment.js

@@ -1,55 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-import damagePropertiesByName from '/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js';
-
-export default function applyAdjustment({
-  prop,
-  creature,
-  targets,
-  actionContext,
-  log
-}){
-  let damageTargets = prop.target === 'self' ? [creature] : targets;
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  var {result, context} = evaluateString({
-    string: prop.amount,
-    scope,
-    fn: 'reduce'
-  });
-  context.errors.forEach(e => {
-    log.content.push({
-      name: 'Attribute damage error',
-      value: e.message || e.toString(),
-    });
-  });
-  if (damageTargets) {
-    damageTargets.forEach(target => {
-      if (prop.target === 'each'){
-        ({result} = evaluateString({
-          string: prop.amount,
-          scope,
-          fn: 'reduce'
-        }));
-      }
-      damagePropertiesByName.call({
-        creatureId: target._id,
-        variableName: prop.stat,
-        operation: prop.operation || 'increment',
-        value: result.value,
-      });
-      log.content.push({
-        name: 'Attribute damage',
-        value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-        ` ${result.isNumber ? -result.value : result.toString()}`,
-      });
-    });
-  } else {
-    log.content.push({
-      name: 'Attribute damage',
-      value: `${prop.stat}${prop.operation === 'set' ? ' set to' : ''}` +
-      ` ${result.isNumber ? -result.value : result.toString()}`,
-    });
-  }
-}

app/imports/api/creature/actions/applyAttack.js

@@ -1,22 +0,0 @@
-import roll from '/imports/parser/roll.js';
-
-export default function applyAttack({
-  prop,
-  log,
-  actionContext,
-  creature,
-}){
-  let value = roll(1, 20)[0];
-  actionContext.attackRoll = {value};
-  let criticalHitTarget = creature.variables.criticalHitTarget &&
-    creature.variables.criticalHitTarget.currentValue || 20;
-  let criticalHit = value >= criticalHitTarget;
-  if (criticalHit) actionContext.criticalHit = {value: true};
-  let result = value + prop.rollBonusResult;
-  actionContext.toHit = {value: result};
-
-  log.content.push({
-    name: criticalHit ? 'Critical Hit!' : 'To Hit',
-    value: `1d20 [${value}] + ${prop.rollBonusResult} = ` + result,
-  });
-}

app/imports/api/creature/actions/applyBuff.js

@@ -1,61 +0,0 @@
-import {
-	setLineageOfDocs,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import {setDocToLastOrder} from '/imports/api/parenting/order.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function applyBuff({
-  prop,
-  children,
-  creature,
-  targets = [],
-  //actionContext,
-}){
-  let buffTargets = prop.target === 'self' ? [creature] : targets;
-
-  //let scope = {
-  //  ...creature.variables,
-  //  ...actionContext,
-  //};
-
-  // TODO
-  // If the target is not self, walk through all decendants and replace
-  // variables in calculations with their values from the creature scope
-  // If the target is self, replace all the target.x references with just x
-
-  // Then copy the decendants of the buff to the targets
-  prop.applied = true;
-  let propList = [prop];
-  function addChildrenToPropList(children){
-    children.forEach(child => {
-      propList.push(child.node);
-      addChildrenToPropList(child.children);
-    });
-  }
-  addChildrenToPropList(children);
-  let oldParent = {
-    id: prop.parent.id,
-    collection: prop.parent.collection,
-  };
-  buffTargets.forEach(target => {
-    copyNodeListToTarget(propList, target, oldParent);
-  });
-}
-
-function copyNodeListToTarget(propList, target, oldParent){
-  let ancestry = [{collection: 'creatures', id: target._id}];
-  setLineageOfDocs({
-    docArray: propList,
-    newAncestry: ancestry,
-    oldParent,
-  });
-  renewDocIds({
-    docArray: propList,
-  });
-  setDocToLastOrder({
-    collection: CreatureProperties,
-    doc: propList[0],
-  });
-  CreatureProperties.batchInsert(propList);
-}

app/imports/api/creature/actions/applyDamage.js

@@ -1,115 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-import dealDamage from '/imports/api/creature/creatureProperties/methods/dealDamage.js';
-import {insertCreatureLog} from '/imports/api/creature/log/CreatureLogs.js';
-import { CompilationContext } from '/imports/parser/parser.js';
-
-export default function applyDamage({
-  prop,
-  creature,
-  targets,
-  actionContext,
-  log,
-}){
-  let damageTargets = prop.target === 'self' ? [creature] : targets;
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  // Add the target's variables to the scope
-  if (targets.length === 1){
-    scope.target = targets[0].variables;
-  }
-  // Determine if the hit is critical
-  let criticalHit = !!(
-    actionContext.criticalHit &&
-    actionContext.criticalHit.value &&
-    prop.damageType !== 'healing' // Can't critically heal
-  );
-  // Double the damage rolls if the hit is critical
-  let context = new CompilationContext({
-    doubleRolls: criticalHit,
-  });
-
-  // Compute the roll the first time, logging any errors
-  var {result} = evaluateString({
-    string: prop.amount,
-    scope,
-    fn: 'reduce',
-    context
-  });
-
-  // If the result is an error bail out now
-  if (result.constructor.name === 'ErrorNode'){
-    log.content.push({
-      name: 'Damage error',
-      value: result.toString(),
-    });
-    return;
-  }
-
-  // Memoise the damage suffix for the log
-  let suffix = (criticalHit ? ' critical ' : ' ') +
-    prop.damageType +
-    (prop.damageType !== ' healing ' ? ' damage ': '');
-
-  if (damageTargets && damageTargets.length) {
-    // Iterate through all the targets
-    damageTargets.forEach(target => {
-      let name = prop.damageType === 'healing' ? 'Healing' : 'Damage';
-
-      // Reroll the damage if needed
-      if (prop.target === 'each'){
-        ({result, context} = evaluateString({
-          string: prop.amount,
-          scope,
-          fn: 'reduce'
-        }));
-      }
-      // If the result is an error or not a number bail out now
-      if (result.constructor.name === 'ErrorNode' || !result.isNumber){
-        log.content.push({
-          name: 'Damage error',
-          value: result.toString(),
-        });
-        return;
-      }
-
-      // Deal the damage to the target
-      let damageDealt = dealDamage.call({
-        creatureId: target._id,
-        damageType: prop.damageType,
-        amount: result.value,
-      });
-
-      // Log the damage done
-      if (target._id === creature._id){
-        // Target is same as self, log damage as such
-        log.content.push({
-          name,
-          value: damageDealt + suffix + ' to self',
-        });
-      } else {
-        log.content.push({
-          name,
-          value: 'Dealt ' + damageDealt + suffix + ` ${target.name && ' to '}${target.name}`,
-        });
-        // Log the damage received on that creature's log as well
-        insertCreatureLog.call({
-          log: {
-            creatureId: target._id,
-            content: [{
-              name,
-              value: 'Recieved ' + damageDealt + suffix,
-            }],
-          }
-        });
-      }
-    });
-  } else {
-    // There are no targets, just log the result
-    log.content.push({
-      name: prop.damageType === 'healing' ? 'Healing' : 'Damage',
-      value: result.toString() + suffix,
-    });
-  }
-}

app/imports/api/creature/actions/applyProperties.js

@@ -1,82 +0,0 @@
-import applyAction from '/imports/api/creature/actions/applyAction.js';
-import applyAdjustment from '/imports/api/creature/actions/applyAdjustment.js';
-import applyAttack from '/imports/api/creature/actions/applyAttack.js';
-import applyBuff from '/imports/api/creature/actions/applyBuff.js';
-import applyDamage from '/imports/api/creature/actions/applyDamage.js';
-import applyRoll from '/imports/api/creature/actions/applyRoll.js';
-import applyToggle from '/imports/api/creature/actions/applyToggle.js';
-import applySave from '/imports/api/creature/actions/applySave.js';
-
-function applyProperty(options){
-  let prop = options.prop;
-  if (prop.type === 'buff'){
-    // ignore only applied buffs, don't apply them again
-    if (prop.applied === true){
-      return false;
-    }
-  // Only ignore toggles if they wont be computed
-  } else if (prop.type === 'toggle') {
-    if (prop.disabled) return false;
-    if (prop.enabled) return true;
-    if (!prop.condition) return false;
-  // Ignore inactive props of other types
-  } else if (prop.deactivatedBySelf === true){
-    return false;
-  }
-  switch (prop.type){
-    case 'action':
-    case 'spell':
-      applyAction(options);
-      break;
-    case 'attack':
-      applyAction(options);
-      applyAttack(options);
-      break;
-    case 'damage':
-      applyDamage(options);
-      break;
-    case 'adjustment':
-      applyAdjustment(options);
-      break;
-    case 'buff':
-      applyBuff(options);
-      return false;
-    case 'toggle':
-      return applyToggle(options);
-    case 'roll':
-      applyRoll(options);
-      break;
-    case 'savingThrow':
-      return applySave(options);
-  }
-  return true;
-}
-
-function applyPropertyAndWalkChildren({prop, children, targets, ...options}){
-  let shouldKeepWalking = applyProperty({ prop, children, targets, ...options });
-  if (shouldKeepWalking){
-    applyProperties({ forest: children, targets, ...options,});
-  }
-}
-
-export default function applyProperties({ forest, targets, ...options}){
-  forest.forEach(node => {
-    let prop = node.node;
-    options.actionContext[`#${prop.type}`] = prop;
-    let children = node.children;
-    if (shouldSplit(prop) && targets.length){
-      targets.forEach(target => {
-        let targets = [target]
-        applyPropertyAndWalkChildren({ targets, prop, children, ...options});
-      });
-    } else {
-      applyPropertyAndWalkChildren({prop, children, targets, ...options});
-    }
-  });
-}
-
-function shouldSplit(prop){
-  if (prop.target === 'each'){
-    return true;
-  }
-}

app/imports/api/creature/actions/applyRoll.js

@@ -1,25 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-
-export default function applyRoll({
-  prop,
-  creature,
-  actionContext,
-  log,
-}){
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  var {result} = evaluateString({
-    string: prop.roll,
-    scope,
-    fn: 'reduce'
-  });
-  if (result.isNumber){
-    actionContext[prop.variableName] = result.value;
-  }
-  log.content.push({
-    name: prop.name,
-    value: prop.variableName + ' = ' + prop.roll + ' = ' + result.toString(),
-  });
-}

app/imports/api/creature/actions/applySave.js

@@ -1,76 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-import CreaturesProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import roll from '/imports/parser/roll.js';
-
-export default function applySave({
-  prop,
-  creature,
-  actionContext,
-  log,
-}){
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  try {
-    // Calculate the DC
-    var {result} = evaluateString({
-      string: prop.dc,
-      scope,
-      fn: 'reduce'
-    });
-    let dc = result.value;
-    log.content.push({
-      name: prop.name,
-      value: ' DC ' + result.toString(),
-    });
-    if (prop.target === 'self'){
-      let save = CreaturesProperties.findOne({
-        'ancestors.id': creature._id,
-        type: 'skill',
-        skillType: 'save',
-        variableName: prop.stat,
-        removed: {$ne: true},
-        inactive: {$ne: true},
-      });
-      if (!save){
-        log.content.push({
-          name: 'Saving throw error',
-          value: 'No saving throw found: ' + prop.stat,
-        });
-        return;
-      }
-      let value, values, resultPrefix;
-      if (save.advantage === 1){
-        values = roll(2, 20).sort().reverse();
-        value = values[0];
-        resultPrefix = `Advantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
-      } else if (save.advantage === -1){
-        values = roll(2, 20).sort();
-        value = values[0];
-        resultPrefix = `Disadvantage: 1d20 [${values[0]},~~${values[1]}~~] + ${save.value} = `
-      } else {
-        values = roll(1, 20);
-        value = values[0];
-        resultPrefix = `1d20 [${value}] + ${save.value} = `
-      }
-      actionContext.savingThrowRoll = {value};
-      let result = value + save.value;
-      actionContext.savingThrow = {value: result};
-      let saveSuccess = result >= dc;
-      log.content.push({
-        name: 'Save',
-        value: resultPrefix + result + (saveSuccess ? 'Passed' : 'Failed')
-      });
-      return !saveSuccess;
-    } else {
-      // TODO
-      return true;
-    }
-  } catch (e){
-    log.content.push({
-      name: 'Save error',
-      value: e.toString(),
-    });
-  }
-}

app/imports/api/creature/actions/applyToggle.js

@@ -1,33 +0,0 @@
-import evaluateString from '/imports/api/creature/computation/afterComputation/evaluateString.js';
-
-export default function applyToggle({
-  prop,
-  creature,
-  actionContext,
-  log,
-}){
-  let scope = {
-    ...creature.variables,
-    ...actionContext,
-  };
-  if (Number.isFinite(+prop.condition)){
-    return !!+prop.condition;
-  }
-  var {result} = evaluateString({
-    string: prop.condition,
-    scope,
-    fn: 'reduce'
-  });
-  if (result.constructor.name === 'ErrorNode') {
-    log.content.push({
-      name: 'Toggle error',
-      value: result.toString(),
-    });
-    return false;
-  }
-  log.content.push({
-    name: prop.name || 'Toggle',
-    value: prop.condition + ' = ' + result.toString(),
-  });
-  return !!result.value;
-}

app/imports/api/creature/actions/castSpellWithSlot.js

@@ -1,82 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import { doActionWork } from '/imports/api/creature/actions/doAction.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import getAncestorContext from '/imports/api/creature/actions/getAncestorContext.js';
-
-const castSpellWithSlot = new ValidatedMethod({
-  name: 'creatureProperties.castSpellWithSlot',
-  validate: new SimpleSchema({
-    spellId: SimpleSchema.RegEx.Id,
-    slotId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-    targetId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({spellId, slotId, targetId}) {
-    let spell = CreatureProperties.findOne(spellId);
-		// Check permissions
-    let creature = getRootCreatureAncestor(spell);
-    assertEditPermission(creature, this.userId);
-    let target = undefined;
-    if (targetId) {
-      target = Creatures.findOne(targetId);
-      assertEditPermission(target, this.userId);
-    }
-    let slotLevel = spell.level || 0;
-    if (slotLevel !== 0){
-      let slot = CreatureProperties.findOne(slotId);
-      if (!slot){
-        throw new Meteor.Error('No slot',
-          'Slot not found to cast spell');
-      }
-      if (!slot.currentValue){
-        throw new Meteor.Error('No slot',
-          'Slot depleted');
-      }
-      if (!(slot.spellSlotLevelValue >= spell.level)){
-        throw new Meteor.Error('Slot too small',
-          'Slot is not large enough to cast spell');
-      }
-      slotLevel = slot.spellSlotLevelValue;
-      damagePropertyWork({
-        property: slot,
-        operation: 'increment',
-        value: 1,
-      });
-    }
-    let actionContext = getAncestorContext(spell);
-
-		doActionWork({
-      action: spell,
-      actionContext: {slotLevel, ...actionContext},
-      creature,
-      targets: target ? [target] : [],
-      method: this,
-    });
-    // Note this only recomputes the top-level creature, not the nearest one
-		recomputeCreatureByDoc(creature);
-    if (target){
-      recomputeCreatureByDoc(target);
-    }
-  },
-});
-
-export default castSpellWithSlot;

app/imports/api/creature/actions/doAction.js

@@ -1,99 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { CreatureLogSchema, insertCreatureLogWork } from '/imports/api/creature/log/CreatureLogs.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import { nodesToTree } from '/imports/api/parenting/parenting.js';
-import applyProperties from '/imports/api/creature/actions/applyProperties.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import getAncestorContext from '/imports/api/creature/actions/getAncestorContext.js';
-
-const doAction = new ValidatedMethod({
-  name: 'creatureProperties.doAction',
-  validate: new SimpleSchema({
-    actionId: SimpleSchema.RegEx.Id,
-    targetIds: {
-      type: Array,
-      defaultValue: [],
-      maxCount: 10,
-      optional: true,
-    },
-    'targetIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({actionId, targetIds = []}) {
-    let action = CreatureProperties.findOne(actionId);
-		// Check permissions
-    let creature = getRootCreatureAncestor(action);
-
-    // Build ancestor context
-    let actionContext = getAncestorContext(action);
-
-    assertEditPermission(creature, this.userId);
-    let targets = [];
-    targetIds.forEach(targetId => {
-      let target = Creatures.findOne(targetId);
-      assertEditPermission(target, this.userId);
-      targets.push(target);
-    });
-		doActionWork({action, creature, targets, actionContext, method: this});
-
-    // The acting creature might have used ammo
-    recomputeInventory(creature._id);
-
-    // The action might add properties which need to be activated
-    recomputeInactiveProperties(creature._id);
-
-    // recompute creatures
-		recomputeCreatureByDoc(creature);
-    targets.forEach(target => {
-      recomputeInactiveProperties(target._id);
-      recomputeCreatureByDoc(target);
-    });
-  },
-});
-
-export function doActionWork({
-  action,
-  creature,
-  targets,
-  actionContext = {},
-  method
-}){
-  // Create the log
-  let log = CreatureLogSchema.clean({
-    creatureId: creature._id,
-    creatureName: creature.name,
-  });
-
-  let decendantForest = nodesToTree({
-    collection: CreatureProperties,
-    ancestorId: action._id,
-  });
-  let startingForest = [{
-    node: action,
-    children: decendantForest,
-  }];
-  applyProperties({
-    forest: startingForest,
-    actionContext,
-    creature,
-    targets,
-    log,
-  });
-  insertCreatureLogWork({log, creature, method});
-}
-
-export default doAction;

app/imports/api/creature/actions/doCheck.js

@@ -1,56 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import roll from '/imports/parser/roll.js';
-
-const doCheck = new ValidatedMethod({
-  name: 'creature.doCheck',
-  validate: new SimpleSchema({
-    creatureId: {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-      optional: true,
-    },
-    attributeName: {
-      type: String,
-      optional: true,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 10,
-    timeInterval: 5000,
-  },
-  run({creatureId, attributeName}) {
-    let creature = Creatures.findOne(creatureId);
-    assertEditPermission(creature, this.userId);
-    let bonus = getAttributeValue({creature, attributeName})
-		return doCheckWork({bonus});
-  },
-});
-
-function getAttributeValue({creature, attributeName}){
-  let att = creature.variables[attributeName];
-  if (!att) throw new Meteor.Error('No such attribute',
-    `This creature does not have a ${attributeName} property`);
-  let bonus = att.attributeType === 'ability'? att.modifier : att.value;
-  return bonus || 0;
-}
-
-export function doCheckWork({bonus, advantage = 0}){
-  let rolls = roll(2,20);
-  let chosenRoll;
-  if (advantage === 1){
-    chosenRoll = Math.max.apply(rolls);
-  } else if (advantage === -1){
-    chosenRoll = Math.min.apply(rolls);
-  } else {
-    chosenRoll = rolls[0];
-  }
-  let result = chosenRoll + bonus;
-  return {rolls, bonus, chosenRoll, result};
-}
-
-export default doCheck;

app/imports/api/creature/actions/getAncestorContext.js

@@ -1,15 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getAncestorContext(prop){
-  // Build ancestor context
-  const actionContext = {};
-  let ancestorIds = prop.ancestors.map(ref => ref.id);
-  CreatureProperties.find({
-    _id: {$in: ancestorIds}
-  }, {
-    sort: {order: 1},
-  }).forEach(ancestor => {
-    actionContext[`#${ancestor.type}`] = ancestor;
-  });
-  return actionContext;
-}

app/imports/api/creature/actions/spendResources.js

@@ -1,93 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { adjustQuantityWork } from '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-
-export default function spendResources({prop, log}){
-  // Check Uses
-  if (prop.usesUsed >= prop.usesResult){
-    throw new Meteor.Error('Insufficient Uses',
-      'This prop has no uses left');
-  }
-  // Resources
-  if (prop.insufficientResources){
-    throw new Meteor.Error('Insufficient Resources',
-      'This creature doesn\'t have sufficient resources to perform this prop');
-  }
-  // Items
-  let itemQuantityAdjustments = [];
-  let spendLog = [];
-  let gainLog = [];
-  prop.resources.itemsConsumed.forEach(itemConsumed => {
-    if (!itemConsumed.itemId){
-      throw new Meteor.Error('Ammo not selected',
-        'No ammo was selected for this prop');
-    }
-    let item = CreatureProperties.findOne(itemConsumed.itemId);
-    if (!item || item.ancestors[0].id !== prop.ancestors[0].id){
-      throw new Meteor.Error('Ammo not found',
-        'The prop\'s ammo was not found on the creature');
-    }
-    if (!item.equipped){
-      throw new Meteor.Error('Ammo not equipped',
-        'The selected ammo is not equipped');
-    }
-    if (!itemConsumed.quantity) return;
-    itemQuantityAdjustments.push({
-      property: item,
-      operation: 'increment',
-      value: itemConsumed.quantity,
-    });
-    let logName = item.name;
-    if (itemConsumed.quantity > 1 || itemConsumed.quantity < -1){
-      logName = item.plural || logName;
-    }
-    if (itemConsumed.quantity > 0){
-      spendLog.push(logName + ': ' + itemConsumed.quantity);
-    } else if (itemConsumed.quantity < 0){
-      gainLog.push(logName + ': ' + -itemConsumed.quantity);
-    }
-  });
-  // No more errors should be thrown after this line
-  // Now that we have confirmed that there are no errors, do actual work
-  //Items
-  itemQuantityAdjustments.forEach(adjustQuantityWork);
-
-  // Use uses
-  if (prop.usesResult){
-    CreatureProperties.update(prop._id, {
-      $inc: {usesUsed: 1}
-    }, {
-      selector: prop
-    });
-    log.content.push({
-      name: 'Uses left',
-      value: prop.usesResult - (prop.usesUsed || 0) - 1,
-    });
-  }
-
-  // Damage stats
-  prop.resources.attributesConsumed.forEach(attConsumed => {
-    if (!attConsumed.quantity) return;
-    let stat = CreatureProperties.findOne(attConsumed.statId);
-    damagePropertyWork({
-      property: stat,
-      operation: 'increment',
-      value: attConsumed.quantity,
-    });
-    if (attConsumed.quantity > 0){
-      spendLog.push(stat.name + ': ' + attConsumed.quantity);
-    } else if (attConsumed.quantity < 0){
-      gainLog.push(stat.name + ': ' + -attConsumed.quantity);
-    }
-  });
-
-  // Log all the spending
-  if (gainLog.length) log.content.push({
-    name: 'Gained',
-    value: gainLog.join('\n'),
-  });
-  if (spendLog.length) log.content.push({
-    name: 'Spent',
-    value: spendLog.join('\n'),
-  });
-}

app/imports/api/creature/archive/ArchiveCreatureFiles.js

@@ -0,0 +1,62 @@
+
+import SimpleSchema from 'simpl-schema';
+import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed';
+import { CreaturePropertySchema } from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { CreatureSchema } from '/imports/api/creature/creatures/Creatures';
+import assertUserHasFileSpace from '/imports/api/files/assertUserHasFileSpace';
+let createS3FilesCollection;
+if (Meteor.isServer) {
+  createS3FilesCollection = require('/imports/api/files/server/s3FileStorage').createS3FilesCollection
+} else {
+  createS3FilesCollection = require('/imports/api/files/client/s3FileStorage').createS3FilesCollection
+}
+
+const ArchiveCreatureFiles = createS3FilesCollection({
+  collectionName: 'archiveCreatureFiles',
+  storagePath: Meteor.isDevelopment ? '../../../../../fileStorage/archiveCreatures' : 'assets/app/archiveCreatures',
+  onBeforeUpload(file) {
+    // Allow upload files under 10MB, and only in json format
+    if (file.size > 10485760) {
+      return 'Please upload with size equal or less than 10MB';
+    }
+    // Make sure the user has enough space
+    assertUserHasFileSpace(Meteor.userId(), file.size);
+    // Only accept JSON
+    if (!/json/i.test(file.extension)) {
+      return 'Please upload only a JSON file';
+    }
+    return true;
+  },
+  onAfterUpload(file) {
+    if (Meteor.isServer) incrementFileStorageUsed(file.userId, file.size);
+  }
+});
+
+let archiveSchema = new SimpleSchema({
+  meta: {
+    type: Object,
+    blackbox: true,
+  },
+  creature: CreatureSchema,
+  properties: {
+    type: Array,
+  },
+  'properties.$': CreaturePropertySchema,
+  experiences: {
+    type: Array,
+  },
+  'experiences.$': {
+    type: Object,
+    blackbox: true,
+  },
+  logs: {
+    type: Array,
+  },
+  'logs.$': {
+    type: Object,
+    blackbox: true,
+  },
+});
+
+export default ArchiveCreatureFiles;
+export { archiveSchema };

app/imports/api/creature/archive/ArchivedCreatures.js

@@ -1,57 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-
-// Archived creatures is an immutable collection of creatures that are no longer
-// in use and can be safely archived by the mongoDB hosting service.
-// It keeps the working datasets like creatureProperties much smaller
-// than they would otherwise be.
-let ArchivedCreatures = new Mongo.Collection('archivedCreatures');
-
-// We use blackbox objects for everything:
-// - saves time checking every object against a schema
-// - doesn't accidentaly create indices defined in subschemas
-// - The objects we are archiving have already been checked against their
-//   own schemas
-let ArchivedCreatureSchema = new SimpleSchema({
-  owner: {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-    // The primary index on this collection
-		index: 1,
-	},
-  archiveDate: {
-    type: Date,
-    // Indexed so the archiving system can archive documents when they
-    // get to a certain age
-    index: 1,
-  },
-	creature: {
-    type: Object,
-    blackbox: true,
-  },
-  properties: {
-    type: Array,
-  },
-  'properties.$': {
-    type: Object,
-    blackbox: true,
-  },
-  experiences: {
-    type: Array,
-  },
-  'experiences.$': {
-    type: Object,
-    blackbox: true,
-  },
-  logs: {
-    type: Array,
-  },
-  'logs.$': {
-    type: Object,
-    blackbox: true,
-  },
-});
-
-ArchivedCreatures.attachSchema(ArchivedCreatureSchema);
-
-import '/imports/api/creature/archive/methods/index.js';
-export default ArchivedCreatures;

app/imports/api/creature/archive/methods/archiveCreatureToFile.js

@@ -0,0 +1,100 @@
+import { Meteor } from 'meteor/meteor';
+import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION';
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions';
+import Creatures from '/imports/api/creature/creatures/Creatures';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import CreatureLogs from '/imports/api/creature/log/CreatureLogs';
+import Experiences from '/imports/api/creature/experience/Experiences';
+import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature';
+import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles';
+import { getFilter } from '/imports/api/parenting/parentingFunctions';
+
+export function getArchiveObj(creatureId) {
+  // Build the archive document
+  const creature = Creatures.findOne(creatureId);
+  if (!creature) throw new Meteor.Error('creature-not-found', 'Creature not found');
+  const properties = CreatureProperties.find({ ...getFilter.descendantsOfRoot(creatureId) }).fetch();
+  const experiences = Experiences.find({ creatureId }).fetch();
+  const logs = CreatureLogs.find({ creatureId }).fetch();
+  let archiveCreature = {
+    meta: {
+      type: 'DiceCloud V2 Creature Archive',
+      schemaVersion: SCHEMA_VERSION,
+      archiveDate: new Date(),
+    },
+    creature,
+    properties,
+    experiences,
+    logs,
+  };
+
+  return archiveCreature;
+}
+
+export const archiveCreature = Meteor.wrapAsync(function archiveCreatureFn(creatureId, callback) {
+  const archive = getArchiveObj(creatureId);
+  const buffer = Buffer.from(JSON.stringify(archive, null, 2));
+  ArchiveCreatureFiles.write(buffer, {
+    fileName: `${archive.creature.name || archive.creature._id}.json`,
+    type: 'application/json',
+    userId: archive.creature.owner,
+    meta: {
+      schemaVersion: SCHEMA_VERSION,
+      creatureId: archive.creature._id,
+      creatureName: archive.creature.name,
+    },
+  }, (error, fileRef) => {
+    if (error) {
+      // If there is an error already, just call the callback
+      callback(error);
+    } else if (!Meteor.settings.useS3) {
+      // If we aren't using s3, remove the creature and call the callback
+      removeCreatureWork(creatureId);
+      callback();
+    } else {
+      // Wait for s3Result event that occurs when the s3 attempt to write ends.
+      // If it's successful, remove the creature, otherwise callback with error
+      const resultHandler = (s3Error, resultRef) => {
+        // This event is for a different file, ignore it
+        if (resultRef._id !== fileRef._id) return;
+        // Remove this handler, we are only running it once for this fileId
+        ArchiveCreatureFiles.off('s3Result', resultHandler);
+        // Remove the creature if there was no error
+        if (!s3Error) {
+          removeCreatureWork(creatureId);
+        }
+        // Alert the callback that we're done
+        callback(s3Error);
+      }
+      ArchiveCreatureFiles.on('s3Result', resultHandler);
+    }
+  }, true);
+});
+
+const archiveCreatureToFile = new ValidatedMethod({
+  name: 'Creatures.methods.archiveCreatureToFile',
+  validate: new SimpleSchema({
+    'creatureId': {
+      type: String,
+      max: 32,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  async run({ creatureId }) {
+    assertOwnership(creatureId, this.userId);
+    if (Meteor.isServer) {
+      archiveCreature(creatureId);
+    } else {
+      removeCreatureWork(creatureId);
+    }
+  },
+});
+
+export default archiveCreatureToFile;

app/imports/api/creature/archive/methods/archiveCreatures.js

@@ -1,66 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/creature/creatures/creaturePermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-import ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
-
-function archiveCreature(creatureId){
-  // Build the archive document
-  const creature = Creatures.findOne(creatureId);
-  const properties = CreatureProperties.find({'ancestors.id': creatureId}).fetch();
-  const experiences = Experiences.find({creatureId}).fetch();
-  const logs = CreatureLogs.find({creatureId}).fetch();
-  let archiveCreature = {
-    owner: creature.owner,
-    archiveDate: new Date(),
-    creature,
-    properties,
-    experiences,
-    logs,
-  };
-
-  // Insert it
-  let id = ArchivedCreatures.insert(archiveCreature);
-
-  // Remove the original creature
-  removeCreatureWork(creatureId);
-
-  return id;
-}
-
-const archiveCreatures = new ValidatedMethod({
-  name: 'Creatures.methods.archiveCreatures',
-  validate: new SimpleSchema({
-    creatureIds: {
-      type: Array,
-      max: 10,
-    },
-    'creatureIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 1,
-    timeInterval: 5000,
-  },
-  run({creatureIds}) {
-    for (let id of creatureIds){
-      assertOwnership(id, this.userId)
-    }
-    let archivedIds = [];
-    for (let id of creatureIds){
-      let archivedId = archiveCreature(id);
-      archivedIds.push(archivedId);
-    }
-    return archivedIds;
-  },
-});
-
-export default archiveCreatures;

app/imports/api/creature/archive/methods/index.js

@@ -1,2 +1,3 @@
-import '/imports/api/creature/archive/methods/archiveCreatures.js';
-import '/imports/api/creature/archive/methods/restoreCreatures.js';
+import '/imports/api/creature/archive/methods/archiveCreatureToFile';
+import '/imports/api/creature/archive/methods/restoreCreatureFromFile';
+import '/imports/api/creature/archive/methods/removeArchiveCreature';

app/imports/api/creature/archive/methods/removeArchiveCreature.js

@@ -0,0 +1,40 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles';
+import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed';
+
+const removeArchiveCreature = new ValidatedMethod({
+  name: 'ArchiveCreatureFiles.methods.removeArchiveCreature',
+  validate: new SimpleSchema({
+    'fileId': {
+      type: String,
+      max: 32,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  async run({ fileId }) {
+    // fetch the file
+    const file = ArchiveCreatureFiles.findOne({ _id: fileId }).get();
+    if (!file) {
+      throw new Meteor.Error('File not found',
+        'The requested creature archive does not exist');
+    }
+    // Assert ownership
+    const userId = file?.userId;
+    if (!userId || userId !== this.userId) {
+      throw new Meteor.Error('Permission denied',
+        'You can only restore creatures you own');
+    }
+    //Remove the archive once the restore succeeded
+    ArchiveCreatureFiles.remove({ _id: fileId });
+    // Update the user's file storage limits
+    incrementFileStorageUsed(userId, -file.size);
+  },
+});
+
+export default removeArchiveCreature;

app/imports/api/creature/archive/methods/restoreCreatureFromFile.js

@@ -0,0 +1,104 @@
+import SCHEMA_VERSION from '/imports/constants/SCHEMA_VERSION';
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import Creatures from '/imports/api/creature/creatures/Creatures';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import CreatureLogs from '/imports/api/creature/log/CreatureLogs';
+import Experiences from '/imports/api/creature/experience/Experiences';
+import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature';
+import ArchiveCreatureFiles from '/imports/api/creature/archive/ArchiveCreatureFiles';
+import assertHasCharactersSlots from '/imports/api/creature/creatures/methods/assertHasCharacterSlots';
+import { incrementFileStorageUsed } from '/imports/api/users/methods/updateFileStorageUsed';
+import verifyArchiveSafety from '/imports/api/creature/archive/methods/verifyArchiveSafety';
+
+let migrateArchive;
+if (Meteor.isServer) {
+  migrateArchive = require('/imports/migrations/archive/migrateArchive').default;
+}
+
+function restoreCreature(archive, userId) {
+  if (SCHEMA_VERSION < archive.meta.schemaVersion) {
+    throw new Meteor.Error('Incompatible',
+      'The archive file is from a newer version. Update required to read.')
+  }
+
+  // Migrate and verify the archive meets the current schema
+  migrateArchive(archive);
+
+  // Asset that the archive is safe
+  verifyArchiveSafety(archive);
+
+  // Don't upload creatures twice
+  const existingCreature = Creatures.findOne(archive.creature._id, {
+    fields: { _id: 1 }
+  });
+  if (existingCreature) throw new Meteor.Error('Already exists',
+    'The creature you are trying to restore already exists.')
+
+  // Ensure the user owns the restored creature
+  archive.creature.owner = userId;
+
+  // Insert the creature sub documents
+  // They still have their original _id's
+  Creatures.insert(archive.creature);
+  try {
+    // Add all the properties
+    if (archive.properties && archive.properties.length) {
+      CreatureProperties.batchInsert(archive.properties);
+    }
+    if (archive.experiences && archive.experiences.length) {
+      Experiences.batchInsert(archive.experiences);
+    }
+    if (archive.logs && archive.logs.length) {
+      CreatureLogs.batchInsert(archive.logs);
+    }
+  } catch (e) {
+    // If the above fails, delete the inserted creature
+    removeCreatureWork(archive.creature._id);
+    throw e;
+  }
+}
+
+const restoreCreaturefromFile = new ValidatedMethod({
+  name: 'Creatures.methods.restoreCreaturefromFile',
+  validate: new SimpleSchema({
+    'fileId': {
+      type: String,
+      max: 32,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 10,
+    timeInterval: 5000,
+  },
+  async run({ fileId }) {
+    // fetch the file
+    const file = ArchiveCreatureFiles.findOne({ _id: fileId }).get();
+    if (!file) {
+      throw new Meteor.Error('File not found',
+        'The requested creature archive does not exist');
+    }
+    // Assert ownership
+    const userId = file?.userId;
+    if (!userId || userId !== this.userId) {
+      throw new Meteor.Error('Permission denied',
+        'You can only restore creatures you own');
+    }
+
+    assertHasCharactersSlots(this.userId);
+
+    if (Meteor.isServer) {
+      // Read the file data
+      const archive = await ArchiveCreatureFiles.readJSONFile(file);
+      restoreCreature(archive, this.userId);
+    }
+    //Remove the archive once the restore succeeded
+    ArchiveCreatureFiles.remove({ _id: fileId });
+    // Update the user's file storage limits
+    incrementFileStorageUsed(userId, -file.size);
+  },
+});
+
+export default restoreCreaturefromFile;

app/imports/api/creature/archive/methods/restoreCreatures.js

@@ -1,77 +0,0 @@
-import SimpleSchema from 'simpl-schema';
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertOwnership } from '/imports/api/sharing/sharingPermissions.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import CreatureLogs from '/imports/api/creature/log/CreatureLogs.js';
-import Experiences from '/imports/api/creature/experience/Experiences.js';
-import ArchivedCreatures from '/imports/api/creature/archive/ArchivedCreatures.js';
-import { removeCreatureWork } from '/imports/api/creature/creatures/methods/removeCreature.js';
-
-function restoreCreature(archiveId){
-  // Get the archive
-  const archivedCreature = ArchivedCreatures.findOne(archiveId);
-
-  // Insert the creature sub documents
-  // They still have their original _id's
-  Creatures.insert(archivedCreature.creature);
-  try {
-    // Add all the properties
-    if (archivedCreature.properties && archivedCreature.properties.length){
-      CreatureProperties.batchInsert(archivedCreature.properties);
-    }
-    if (archivedCreature.experiences && archivedCreature.experiences.length){
-      Experiences.batchInsert(archivedCreature.experiences);
-    }
-    if (archivedCreature.logs && archivedCreature.logs.length){
-      CreatureLogs.batchInsert(archivedCreature.logs);
-    }
-    // Remove the archived creature
-    ArchivedCreatures.remove(archiveId);
-  } catch (e) {
-    // If the above fails, delete the inserted creature
-    removeCreatureWork(archivedCreature.creature._id);
-    throw e;
-  }
-
-  // Do not recompute. The creature was in a computed and ordered state when
-  // we archived it, just restore everything as-is
-
-  return archivedCreature.creature._id;
-}
-
-const restoreCreatures = new ValidatedMethod({
-  name: 'Creatures.methods.restoreCreatures',
-  validate: new SimpleSchema({
-    archiveIds: {
-      type: Array,
-      max: 10,
-    },
-    'archiveIds.$': {
-      type: String,
-      regEx: SimpleSchema.RegEx.Id,
-    },
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 1,
-    timeInterval: 5000,
-  },
-  run({archiveIds}) {
-    for (let id of archiveIds){
-      let archivedCreature = ArchivedCreatures.findOne(id, {
-        fields: {owner: 1}
-      });
-      assertOwnership(archivedCreature, this.userId)
-    }
-    let creatureIds = [];
-    for (let id of archiveIds){
-      let creatureId = restoreCreature(id);
-      creatureIds.push(creatureId);
-    }
-    return creatureIds;
-  },
-});
-
-export default restoreCreatures;

app/imports/api/creature/archive/methods/verifyArchiveSafety.js

@@ -0,0 +1,28 @@
+import { slice } from 'lodash';
+import { PER_CREATURE_LOG_LIMIT } from '/imports/api/creature/log/CreatureLogs';
+
+export default function verifyArchiveSafety({ creature, properties, experiences, logs }) {
+  const creatureId = creature._id;
+
+  // Check lengths of arrays
+  if (logs.length > PER_CREATURE_LOG_LIMIT) {
+    logs = slice(logs, 0, PER_CREATURE_LOG_LIMIT);
+  }
+
+  // Check that everything belongs to the right creature
+  logs.forEach(log => {
+    if (log.creatureId !== creatureId) {
+      throw new Meteor.Error('Malicious log', 'Log contains an entry for the wrong creature');
+    }
+  });
+  experiences.forEach(experience => {
+    if (experience.creatureId !== creatureId) {
+      throw new Meteor.Error('Malicious experience', 'Experiences contains an entry for the wrong creature');
+    }
+  });
+  properties.forEach(prop => {
+    if (prop.root?.id !== creatureId) {
+      throw new Meteor.Error('Malicious prop', 'Properties contains an entry for the wrong creature');
+    }
+  });
+}

app/imports/api/creature/computation/afterComputation/embedInlineCalculations.js

@@ -1,11 +0,0 @@
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-
-export default function embedInlineCalculations(string, calculations){
-  if (!string) return '';
-  if (!calculations) return string;
-  let index = 0;
-  return string.replace(INLINE_CALCULATION_REGEX, substring => {
-    let comp = calculations && calculations[index++];
-    return (comp && 'result' in comp) ? comp.result : substring;
-  });
-}

app/imports/api/creature/computation/afterComputation/evaluateString.js

@@ -1,67 +0,0 @@
-import { parse, CompilationContext } from '/imports/parser/parser.js';
-import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
-import SymbolNode from '/imports/parser/parseTree/SymbolNode.js';
-import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
-
-//TODO replace constants with their parsed node
-
-export default function evaluateString({string, scope, fn = 'compile', context}){
-  if (!context){
-    context = new CompilationContext({});
-  }
-  if (!string){
-    context.storeError('No string provided');
-    return {result: {value: string}, context};
-  }
-
-  if (!scope) context.storeError('No scope provided');
-
-  // Parse the string using mathjs
-  let node;
-  try {
-    node = parse(string);
-  } catch (e) {
-    context.storeError(e);
-    return {result: {value: string}, context};
-  }
-  node = replaceConstants({calc: node, context, scope});
-  let result = node[fn](scope, context);
-  return {result, context};
-}
-
-// Replace constants in the calc with the right ParseNodes
-function replaceConstants({calc, context, scope}){
-  let constFailed = [];
-  calc = calc.replaceNodes(node => {
-    if (!(node instanceof SymbolNode)) return;
-    let constant = scope[node.name];
-    // replace constants that aren't overridden by stats or disabled by a toggle
-    if (constant && constant.type === 'constant'){
-      // Fail if the constant has errors
-      if (constant.errors && constant.errors.length){
-        constFailed.push(node.name);
-        return;
-      }
-      let parsedConstantNode;
-      try {
-        parsedConstantNode = parse(constant.calculation);
-      } catch(e){
-        constFailed.push(node.name);
-        return;
-      }
-      if (!parsedConstantNode) constFailed.push(node.name);
-      return parsedConstantNode;
-    }
-  });
-  constFailed.forEach(name => {
-    context.storeError({
-      type: 'error',
-      message: `${name} is a constant property with parsing errors`
-    });
-  });
-  let failed = !!constFailed.length;
-  if (failed){
-    calc = new ErrorNode({error: 'Failed to replace constants'});
-  }
-  return calc;
-}

app/imports/api/creature/computation/creatureComputation.test.js

@@ -1,97 +0,0 @@
-import {computeCreature} from "./recomputeCreature.js";
-import assert from "assert";
-
-const makeEffect = function(operation, value){
-  let effect = {computed: false, result: 0, operation}
-  if (_.isFinite(value)){
-    effect.value = +value;
-  } else {
-    effect.calculation = value;
-  }
-  return effect;
-}
-
-describe('computeCreature', function () {
-  it('computes an aritrary creature', function () {
-    let char = {
-      atts: {
-        attribute1: {
-          computed: false,
-          busyComputing: false,
-          type: "attribute",
-          attributeType: "ability",
-          result: 0,
-          mod: 0, // The resulting modifier if this is an ability
-          base: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          effects: [
-            makeEffect("base", 10),
-            makeEffect("add", 5),
-            makeEffect("mul", 2),
-          ],
-        },
-        attribute2: {
-          computed: false,
-          busyComputing: false,
-          type: "attribute",
-          result: 0,
-          mod: 0, // The resulting modifier if this is an ability
-          base: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          effects: [
-            makeEffect("base", "attribute1"),
-            makeEffect("max", 2),
-          ],
-        },
-      },
-      skills: {
-        skill1: {
-          computed: false,
-          busyComputing: false,
-          type: "skill",
-          ability: "attribute1",
-          result: 0,
-          proficiency: 0,
-          add: 0,
-          mul: 1,
-          min: Number.NEGATIVE_INFINITY,
-          max: Number.POSITIVE_INFINITY,
-          advantage: 0,
-          disadvantage: 0,
-          passiveAdd: 0,
-          fail: 0,
-          conditional: 0,
-          effects: [],
-          proficiencies: [],
-        },
-      },
-      dms: {
-        dm1: {
-          computed: false,
-          busyComputing: false,
-          type: "damageMultiplier",
-          result: 0,
-          immunityCount: 0,
-          ressistanceCount: 0,
-          vulnerabilityCount: 0,
-          effects: [],
-        }
-      },
-      classes: {
-        Barbarian: {
-          level: 5,
-        },
-      },
-      level: 5,
-    };
-    char = computeCreature(char);
-    console.log(char);
-    assert(true);
-  });
-});

app/imports/api/creature/computation/engine/ComputationMemo.js

@@ -1,289 +0,0 @@
-import { includes, cloneDeep } from 'lodash';
-import findAncestorByType from '/imports/api/creature/computation/engine/findAncestorByType.js';
-
-// The computation memo is an in-memory data structure used only during the
-// computation process
-export default class ComputationMemo {
-  constructor(props, creature){
-    this.statsByVariableName = {};
-    this.constantsByVariableName = {};
-    this.constantsById = {};
-    this.extraStatsByVariableName = {};
-    this.statsById = {};
-    this.originalPropsById = {};
-    this.propsById = {};
-    this.skillsByAbility = {};
-    this.unassignedEffects = [];
-    this.classLevelsById = {};
-    this.classes = {};
-    this.togglesById = {};
-    this.toggleIds = new Set();
-    // Equipped items that might be used as ammo
-    this.equipmentById = {};
-    // Properties that have calculations, but don't impact other properties
-    this.endStepPropsById = {};
-    // First note all the ids of all the toggles
-    props.forEach((prop) => {
-      if (
-        prop.type === 'toggle'
-      ) {
-        this.toggleIds.add(prop._id);
-      }
-    });
-    props.filter((prop) => {
-      if (
-        prop.type === 'toggle'
-      ) {
-        this.addToggle(prop);
-      } else {
-        return true;
-      }
-    }).filter((prop) => {
-      if (
-        prop.type === 'attribute' ||
-        prop.type === 'skill'
-      ) {
-        // Add all the stats
-        this.addStat(prop);
-      } else if (
-        prop.type === 'item'
-      ) {
-        this.addEquipment(prop);
-      } else {
-        return true;
-      }
-    }).forEach((prop) => {
-      // Now add everything else
-      if (prop.type === 'effect'){
-        this.addEffect(prop);
-      } else if (prop.type === 'proficiency') {
-        this.addProficiency(prop);
-      } else if (prop.type === 'classLevel'){
-        this.addClassLevel(prop);
-      } else if (prop.type === 'constant'){
-        this.addConstant(prop);
-      } else {
-        this.addEndStepProp(prop);
-      }
-    });
-    for (let name in creature.denormalizedStats){
-      if (!this.statsByVariableName[name]){
-        this.statsByVariableName[name] = {
-          variableName: name,
-          value: creature.denormalizedStats[name],
-          computationDetails: propDetailsByType.denormalizedStat(),
-        }
-      }
-    }
-  }
-  addConstant(prop){
-    prop = this.registerProperty(prop);
-    this.constantsById[prop._id] = prop;
-  }
-  registerProperty(prop){
-    this.originalPropsById[prop._id] = cloneDeep(prop);
-    this.propsById[prop._id] = prop;
-    prop.dependencies = [];
-    prop.computationDetails = propDetails(prop);
-    prop.ancestors.forEach(ancestor => {
-      if (this.toggleIds.has(ancestor.id)){
-        prop.computationDetails.toggleAncestors.push(ancestor.id);
-      }
-    });
-    return prop;
-  }
-  addToggle(prop){
-    prop = this.registerProperty(prop);
-    this.togglesById[prop._id] = prop;
-  }
-  addClassLevel(prop){
-    prop = this.registerProperty(prop);
-    this.classLevelsById[prop._id] = prop;
-  }
-  addStat(prop){
-    let variableName = prop.variableName;
-    if (!variableName) return;
-    let existingStat = this.statsByVariableName[variableName];
-    prop = this.registerProperty(prop);
-    if (existingStat){
-      existingStat.computationDetails.idsOfSameName.push(prop._id);
-    } else {
-      this.statsById[prop._id] = prop;
-      this.statsByVariableName[variableName] = prop;
-      if (
-        prop.type === 'skill' &&
-        isSkillCheck(prop) &&
-        prop.ability
-      ){
-        this.addSkillToAbility(prop, prop.ability)
-      }
-    }
-  }
-  addSkillToAbility(prop, ability){
-    if (!this.skillsByAbility[ability]){
-      this.skillsByAbility[ability] = [];
-    }
-    this.skillsByAbility[ability].push(prop);
-  }
-  addEffect(prop){
-    prop = this.registerProperty(prop);
-    let targets = this.getEffectTargets(prop);
-    targets.forEach(target => {
-      if (target.computationDetails && target.computationDetails.effects){
-        target.computationDetails.effects.push(prop);
-      }
-    });
-    if (!targets.size){
-      this.unassignedEffects.push(prop);
-    }
-  }
-  getEffectTargets(prop){
-    let targets = new Set();
-    if (!prop.stats) return targets;
-    prop.stats.forEach((statName) => {
-      let target;
-      if (statName[0] === '#'){
-        target = findAncestorByType({
-          type: statName.slice(1),
-          prop,
-          memo: this
-        });
-      } else {
-        target = this.statsByVariableName[statName];
-      }
-      if (!target) return;
-      targets.add(target);
-      if (isSkillOperation(prop) && isAbility(target)){
-        let extras = this.skillsByAbility[statName] || [];
-        extras.forEach(ex =>{
-          // Only pass on ability effects to skills and checks
-          if (ex.skillType === 'skill' || ex.skillType === 'check'){
-            targets.add(ex)
-          }
-        });
-      }
-    });
-    return targets;
-  }
-  addProficiency(prop){
-    prop = this.registerProperty(prop);
-    let targets = this.getProficiencyTargets(prop);
-    targets.forEach(target => {
-      if(target.computationDetails.proficiencies){
-        target.computationDetails.proficiencies.push(prop);
-      }
-    });
-  }
-  getProficiencyTargets(prop){
-    let targets = new Set();
-    if (!prop.stats) return targets;
-    prop.stats.forEach(statName => {
-      let target = this.statsByVariableName[statName];
-      if (!target) return;
-      targets.add(target);
-      if (isAbility(target)) {
-        let extras = this.skillsByAbility[statName] || [];
-        extras.forEach(ex =>{
-          // Only pass on ability proficiencies to skills and checks
-          if (ex.skillType === 'skill' || ex.skillType === 'check'){
-            targets.add(ex)
-          }
-        });
-      }
-    });
-    return targets;
-  }
-  addEquipment(prop){
-    prop = this.registerProperty(prop);
-    this.equipmentById[prop._id] = prop;
-  }
-  addEndStepProp(prop){
-    prop = this.registerProperty(prop);
-    this.endStepPropsById[prop._id] = prop;
-  }
-}
-
-function isAbility(prop){
-  return prop.type === 'attribute' &&
-  prop.attributeType === 'ability'
-}
-
-function isSkillCheck(prop){
-  return includes(['skill', 'check', 'save', 'utility'], prop.skillType);
-}
-
-const skillOperations = [
-  'advantage',
-  'disadvantage',
-  'passiveAdd',
-  'fail',
-  'conditional',
-  'rollBonus',
-];
-
-function isSkillOperation(prop){
-  return skillOperations.includes(prop.operation);
-}
-
-function propDetails(prop){
-  return propDetailsByType[prop.type] && propDetailsByType[prop.type]() ||
-    propDetailsByType.default();
-}
-
-const propDetailsByType = {
-  default(){
-    return {
-      toggleAncestors: [],
-    };
-  },
-  toggle(){
-    return {
-      computed: false,
-      busyComputing: false,
-      toggleAncestors: [],
-    };
-  },
-  attribute(){
-    return {
-      computed: false,
-      busyComputing: false,
-      effects: [],
-      proficiencies: [],
-      toggleAncestors: [],
-      idsOfSameName: [],
-    };
-  },
-  skill(){
-    return {
-      computed: false,
-      busyComputing: false,
-      effects: [],
-      proficiencies: [],
-      toggleAncestors: [],
-      idsOfSameName: [],
-    };
-  },
-  effect(){
-    return {
-      computed: false,
-      busyComputing: false,
-      toggleAncestors: [],
-    };
-  },
-  classLevel(){
-    return {
-      computed: true,
-      toggleAncestors: [],
-    };
-  },
-  proficiency(){
-    return {
-      toggleAncestors: [],
-    };
-  },
-  denormalizedStat(){
-    return {
-      toggleAncestors: [],
-    };
-  }
-}

app/imports/api/creature/computation/engine/EffectAggregator.js

@@ -1,78 +0,0 @@
-export default class EffectAggregator{
-  constructor(){
-    this.base = undefined;
-    this.add = 0;
-    this.mul = 1;
-    this.min = Number.NEGATIVE_INFINITY;
-    this.max = Number.POSITIVE_INFINITY;
-    this.advantage = 0;
-    this.disadvantage = 0;
-    this.passiveAdd = undefined;
-    this.fail = 0;
-    this.set = undefined;
-    this.conditional = [];
-    this.rollBonus = [];
-    this.hasNoEffects = true;
-  }
-  addEffect(effect){
-    let result = effect.result;
-    if (this.hasNoEffects) this.hasNoEffects = false;
-    switch(effect.operation){
-      case 'base':
-        // Take the largest base value
-        if (Number.isFinite(result)){
-          if(Number.isFinite(this.base)){
-            this.base = Math.max(this.base, result);
-          } else {
-            this.base = result;
-          }
-        }
-        break;
-      case 'add':
-        // Add all adds together
-        this.add += result;
-        break;
-      case 'mul':
-        // Multiply the muls together
-        this.mul *= result;
-        break;
-      case 'min':
-        // Take the largest min value
-        this.min = result > this.min ? result : this.min;
-        break;
-      case 'max':
-        // Take the smallest max value
-        this.max = result < this.max ? result : this.max;
-        break;
-      case 'set':
-        // Take the highest set value
-        this.set = this.set === undefined || result > this.set ? result : this.set;
-        break;
-      case 'advantage':
-        // Sum number of advantages
-        this.advantage++;
-        break;
-      case 'disadvantage':
-        // Sum number of disadvantages
-        this.disadvantage++;
-        break;
-      case 'passiveAdd':
-        // Add all passive adds together
-        if (this.passiveAdd === undefined) this.passiveAdd = 0;
-        this.passiveAdd += result;
-        break;
-      case 'fail':
-        // Sum number of fails
-        this.fail++;
-        break;
-      case 'conditional':
-        // Store array of conditionals
-        this.conditional.push(result);
-        break;
-      case 'rollBonus':
-        // Store array of roll bonuses
-        this.rollBonus.push(result);
-        break;
-    }
-  }
-}

app/imports/api/creature/computation/engine/applyToggles.js

@@ -1,25 +0,0 @@
-import computeToggle from '/imports/api/creature/computation/engine/computeToggle.js';
-import { union } from 'lodash';
-
-export default function applyToggles(prop, memo){
-  // If it used to be inactive delete those fields
-  if (prop.inactive) prop.inactive = undefined;
-  if (prop.deactivatedByAncestor) prop.deactivatedByAncestor = undefined;
-  if (prop.deactivatedByToggle) prop.deactivatedByToggle = undefined;
-  // Iterate through the toggle ancestors from oldest to nearest
-  prop.computationDetails.toggleAncestors.forEach(toggleId => {
-    let toggle = memo.togglesById[toggleId];
-    computeToggle(toggle, memo);
-    prop.dependencies = union(
-      prop.dependencies,
-      [toggle._id],
-      toggle.dependencies,
-    );
-    // Deactivate if the toggle is false
-    if (!toggle.toggleResult){
-      prop.inactive = true;
-      prop.deactivatedByAncestor = true;
-      prop.deactivatedByToggle = true;
-    }
-  });
-}

app/imports/api/creature/computation/engine/combineStat.js

@@ -1,194 +0,0 @@
-import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import computeProficiency from '/imports/api/creature/computation/engine/computeProficiency.js';
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import { union } from 'lodash';
-
-export default function combineStat(stat, aggregator, memo){
-  if (stat.type === 'attribute'){
-    combineAttribute(stat, aggregator, memo);
-  } else if (stat.type === 'skill'){
-    combineSkill(stat, aggregator, memo);
-  } else if (stat.type === 'damageMultiplier'){
-    combineDamageMultiplier(stat, memo);
-  }
-}
-
-function getAggregatorResult(stat, aggregator){
-  let base;
-  if (!Number.isFinite(aggregator.base)){
-    base = stat.baseValue || 0;
-  } else if (!Number.isFinite(stat.baseValue)){
-    base = aggregator.base || 0;
-  } else {
-    base = Math.max(aggregator.base, stat.baseValue);
-  }
-  let result = (base + aggregator.add) * aggregator.mul;
-  if (result < aggregator.min) {
-    result = aggregator.min;
-  }
-  if (result > aggregator.max) {
-    result = aggregator.max;
-  }
-  if (aggregator.set !== undefined) {
-    result = aggregator.set;
-  }
-  if (!stat.decimal && Number.isFinite(result)){
-    result = Math.floor(result);
-  }
-  return result;
-}
-
-function combineAttribute(stat, aggregator, memo){
-  stat.value = getAggregatorResult(stat, aggregator);
-  if (stat.attributeType === 'spellSlot'){
-    let {
-      result,
-      context,
-      dependencies
-    } = evaluateCalculation({
-      string: stat.spellSlotLevelCalculation,
-      memo,
-      prop: stat,
-    });
-    stat.spellSlotLevelValue = result.value;
-    stat.spellSlotLevelErrors = context.errors;
-    stat.dependencies = union(stat.dependencies, dependencies);
-  }
-  stat.currentValue = stat.value - (stat.damage || 0);
-  // Ability scores get modifiers
-  if (stat.attributeType === 'ability') {
-    stat.modifier = Math.floor((stat.currentValue - 10) / 2);
-  } else {
-    stat.modifier = undefined;
-  }
-  // Hit dice get constitution modifiers
-  stat.constitutionMod = undefined;
-  if (stat.attributeType === 'hitDice') {
-    let conStat = memo.statsByVariableName['constitution'];
-    if (conStat && 'modifier' in conStat){
-      stat.constitutionMod = conStat.modifier;
-      stat.dependencies = union(
-        stat.dependencies,
-        [conStat._id],
-        conStat.dependencies,
-      );
-    }
-  }
-  // Stats that have no effects can be hidden based on a sheet setting
-  stat.hide = aggregator.hasNoEffects &&
-    stat.baseValue === undefined ||
-    undefined
-}
-
-function combineSkill(stat, aggregator, memo){
-  // Skills are based on some ability Modifier
-  let ability = stat.ability && memo.statsByVariableName[stat.ability]
-  if (stat.ability && ability){
-    computeStat(ability, memo);
-    stat.abilityMod = ability.modifier;
-    stat.dependencies = union(
-      stat.dependencies,
-      [ability._id],
-      ability.dependencies,
-    );
-  } else {
-    stat.abilityMod = 0;
-  }
-  // Combine all the child proficiencies
-  stat.proficiency = 0;
-  for (let i in stat.computationDetails.proficiencies){
-    let prof = stat.computationDetails.proficiencies[i];
-    computeProficiency(prof, memo);
-    if (
-      !prof.deactivatedByToggle &&
-      prof.value > stat.proficiency
-    ){
-      stat.proficiency = prof.value;
-      stat.dependencies = union(
-        stat.dependencies,
-        [prof._id],
-        prof.dependencies,
-      );
-    }
-  }
-  // Get the character's proficiency bonus to apply
-  let profBonusStat = memo.statsByVariableName['proficiencyBonus'];
-  let profBonus = profBonusStat && profBonusStat.value;
-
-  if (profBonusStat){
-    stat.dependencies = union(
-      stat.dependencies,
-      [profBonusStat._id],
-      profBonusStat.dependencies,
-    );
-  }
-
-  if (typeof profBonus !== 'number' && memo.statsByVariableName['level']){
-    let levelProp = memo.statsByVariableName['level'];
-    let level = levelProp.value;
-    profBonus = Math.ceil(level / 4) + 1;
-    if (levelProp._id){
-      stat.dependencies = union(stat.dependencies, [levelProp._id]);
-    }
-    if (levelProp.dependencies){
-      stat.dependencies = union(stat.dependencies, levelProp.dependencies);
-    }
-  }
-
-  // Multiply the proficiency bonus by the actual proficiency
-  if(stat.proficiency === 0.49){
-    // Round down proficiency bonus in the special case
-    profBonus = Math.floor(profBonus * 0.5);
-  } else {
-    profBonus = Math.ceil(profBonus * stat.proficiency);
-  }
-
-  // Combine everything to get the final result
-  let base = aggregator.base || 0;
-  let result = (base + stat.abilityMod + profBonus + aggregator.add) * aggregator.mul;
-  if (result < aggregator.min) result = aggregator.min;
-  if (result > aggregator.max) result = aggregator.max;
-  if (aggregator.set !== undefined) {
-    result = aggregator.set;
-  }
-  if (Number.isFinite(result)){
-    result = Math.floor(result);
-  }
-  stat.value = result;
-  // Advantage/disadvantage
-  if (aggregator.advantage && !aggregator.disadvantage){
-    stat.advantage = 1;
-  } else if (aggregator.disadvantage && !aggregator.advantage){
-    stat.advantage = -1;
-  } else {
-    stat.advantage = 0;
-  }
-  // Passive bonus
-  stat.passiveBonus = aggregator.passiveAdd;
-  // conditional benefits
-  stat.conditionalBenefits = aggregator.conditional;
-  // Roll bonuses
-  stat.rollBonus = aggregator.rollBonus;
-  // Forced to fail
-  stat.fail = aggregator.fail;
-  // Rollbonus
-  stat.rollBonuses = aggregator.rollBonus;
-  // Hide
-  stat.hide = aggregator.hasNoEffects &&
-    stat.baseValue === undefined &&
-    stat.proficiency == 0 ||
-    undefined;
-}
-
-function combineDamageMultiplier(stat){
-  if (stat.immunityCount) return 0;
-  let result;
-  if (stat.ressistanceCount && !stat.vulnerabilityCount){
-    result = 0.5;
-  }  else if (!stat.ressistanceCount && stat.vulnerabilityCount){
-    result = 2;
-  } else {
-    result = 1;
-  }
-  stat.value = result;
-}

app/imports/api/creature/computation/engine/computeConstant.js

@@ -1,12 +0,0 @@
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-
-export default function computeConstant(constant, memo){
-  // Apply any toggles
-  applyToggles(constant, memo);
-  if (constant.deactivatedByToggle) return;
-  if (
-    !memo.constantsByVariableName[constant.variableName]
-  ){
-    memo.constantsByVariableName[constant.variableName] = constant
-  }
-}

app/imports/api/creature/computation/engine/computeEffect.js

@@ -1,55 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { union } from 'lodash';
-
-export default function computeEffect(effect, memo){
-  if (effect.computationDetails.computed) return;
-  if (effect.computationDetails.busyComputing){
-    // Trying to compute this effect again while it is already computing.
-    // We must be in a dependency loop.
-    effect.computationDetails.computed = true;
-    effect.result = NaN;
-    effect.computationDetails.busyComputing = false;
-    effect.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', effect);
-    return;
-  }
-  // Before doing any work, mark this effect as busy
-  effect.computationDetails.busyComputing = true;
-
-  // Apply any toggles
-  applyToggles(effect, memo);
-
-  // Determine result of effect calculation
-  delete effect.errors;
-  if (!effect.calculation){
-    if(effect.operation === 'add' || effect.operation === 'base'){
-      effect.result = 0;
-    } else {
-      delete effect.result
-    }
-  } else if (Number.isFinite(+effect.calculation)){
-    effect.result = +effect.calculation;
-  } else if(effect.operation === 'conditional' || effect.operation === 'rollBonus'){
-    effect.result = effect.calculation;
-  } else if(_.contains(['advantage', 'disadvantage', 'fail'], effect.operation)){
-    effect.result = 1;
-  } else {
-    let {
-      result,
-      context,
-      dependencies,
-    } = evaluateCalculation({
-      string: effect.calculation,
-      prop: effect,
-      memo
-    });
-    effect.result = result.value;
-    effect.dependencies = union(effect.dependencies, dependencies);
-    if (context.errors.length){
-      effect.errors = context.errors;
-    }
-  }
-  effect.computationDetails.computed = true;
-  effect.computationDetails.busyComputing = false;
-}

app/imports/api/creature/computation/engine/computeEndStepProperty.js

@@ -1,129 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { union } from 'lodash';
-
-export default function computeEndStepProperty(prop, memo){
-  applyToggles(prop, memo);
-
-  switch (prop.type){
-    case 'action':
-    case 'spell':
-      computeAction(prop, memo);
-      break;
-    case 'adjustment':
-    case 'damage':
-      computePropertyField(prop, memo, 'amount', 'compile');
-      break;
-    case 'attack':
-      computeAction(prop, memo);
-      computePropertyField(prop, memo, 'rollBonus');
-      break;
-    case 'savingThrow':
-      computePropertyField(prop, memo, 'dc');
-      break;
-    case 'spellList':
-      computePropertyField(prop, memo, 'maxPrepared');
-      computePropertyField(prop, memo, 'attackRollBonus');
-      computePropertyField(prop, memo, 'dc');
-      break;
-    case 'propertySlot':
-      computePropertyField(prop, memo, 'quantityExpected');
-      computePropertyField(prop, memo, 'slotCondition');
-      break;
-    case 'roll':
-      computePropertyField(prop, memo, 'roll', 'compile');
-      break;
-  }
-}
-
-function computeAction(prop, memo){
-  // Uses
-  let {
-    result,
-    context,
-    dependencies,
-  } = evaluateCalculation({ string: prop.uses, prop, memo});
-  prop.usesResult = result.value;
-  prop.dependencies = union(prop.dependencies, dependencies);
-  if (context.errors.length){
-    prop.usesErrors = context.errors;
-  } else {
-    delete prop.usesErrors;
-  }
-  prop.insufficientResources = undefined;
-  if (prop.usesUsed >= prop.usesResult){
-    prop.insufficientResources = true;
-  }
-  if (!prop.resources) return;
-  // Attributes consumed
-  prop.resources.attributesConsumed.forEach((attConsumed, i) => {
-    if (attConsumed.variableName){
-      let stat = memo.statsByVariableName[attConsumed.variableName];
-      prop.resources.attributesConsumed[i].statId = stat && stat._id;
-      prop.resources.attributesConsumed[i].statName = stat && stat.name;
-      let available = stat && stat.currentValue || 0;
-      prop.resources.attributesConsumed[i].available = available;
-      if (available < attConsumed.quantity){
-        prop.insufficientResources = true;
-      }
-      if (stat){
-        prop.dependencies = union(
-          prop.dependencies,
-          [stat._id],
-          stat.dependencies
-        );
-      }
-    }
-  });
-  // Items consumed
-  prop.resources.itemsConsumed.forEach((itemConsumed, i) => {
-    let item = itemConsumed.itemId ?
-      memo.equipmentById[itemConsumed.itemId] :
-      undefined;
-    let available = item ? item.quantity : 0;
-    prop.resources.itemsConsumed[i].available = available;
-    if (!item || available < itemConsumed.quantity){
-      prop.insufficientResources = true;
-    }
-    if (item){
-      prop.resources.itemsConsumed[i].itemId = item._id;
-      let name = item.name;
-      if (item.quantity !== 1 && item.plural){
-        name = item.plural;
-      }
-      if (name) prop.resources.itemsConsumed[i].itemName = name;
-      if (item.icon) prop.resources.itemsConsumed[i].itemIcon = item.icon;
-      if (item.color) prop.resources.itemsConsumed[i].itemColor = item.color;
-      prop.dependencies = union(
-        prop.dependencies,
-        [item._id],
-        item.dependencies
-      );
-    } else {
-      delete prop.resources.itemsConsumed[i].itemId;
-      delete prop.resources.itemsConsumed[i].itemName;
-      delete prop.resources.itemsConsumed[i].itemIcon;
-      delete prop.resources.itemsConsumed[i].itemColor;
-    }
-  });
-}
-
-function computePropertyField(prop, memo, fieldName, fn){
-  let {
-    result,
-    context,
-    dependencies,
-  } = evaluateCalculation({string: prop[fieldName], prop, memo, fn});
-  if (result instanceof ConstantNode){
-    prop[`${fieldName}Result`] = result.value;
-  } else {
-    prop[`${fieldName}Result`] = result.toString();
-  }
-  prop.dependencies = union(prop.dependencies, dependencies);
-  if (context.errors.length){
-    prop[`${fieldName}Errors`] = context.errors;
-  } else {
-    delete prop[`${fieldName}Errors`];
-  }
-}

app/imports/api/creature/computation/engine/computeInlineCalculations.js

@@ -1,40 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import INLINE_CALCULATION_REGEX from '/imports/constants/INLINE_CALCULTION_REGEX.js';
-import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
-import { union } from 'lodash';
-
-export default function computeInlineCalculations(prop, memo){
-  if (prop.summary){
-    computeInlineCalcsForField(prop, memo, 'summary');
-  }
-  if (prop.description){
-    computeInlineCalcsForField(prop, memo, 'description');
-  }
-}
-
-function computeInlineCalcsForField(prop, memo, field){
-  let string = prop[field];
-  let inlineComputations = [];
-  let matches = string.matchAll(INLINE_CALCULATION_REGEX);
-  for (let match of matches){
-    let calculation = match[1];
-    let {
-      result,
-      context,
-      dependencies,
-    } = evaluateCalculation({string: calculation, prop, memo, fn: 'compile'});
-    if (result instanceof ErrorNode){
-      result = '`Calculation Error`';
-    }
-    let computation = {
-      calculation,
-      result: result && result.toString(),
-    };
-    if (context.errors.length){
-      computation.errors = context.errors;
-    }
-    inlineComputations.push(computation);
-    prop.dependencies = union(prop.dependencies, dependencies);
-  }
-  prop[`${field}Calculations`] = inlineComputations;
-}

app/imports/api/creature/computation/engine/computeLevels.js

@@ -1,66 +0,0 @@
-import { forOwn, has, union } from 'lodash';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-
-export default function computeLevels(memo){
-  computeClassLevels(memo);
-  computeTotalLevel(memo);
-}
-
-function computeClassLevels(memo){
-  forOwn(memo.classLevelsById, classLevel => {
-    applyToggles(classLevel, memo);
-    //  class levels are mutually dependent
-    classLevel.dependencies = union(
-      classLevel.dependencies,
-      Object.keys(memo.classLevelsById)
-    );
-    if (classLevel.deactivatedByToggle) return;
-    let name = classLevel.variableName;
-    let stat = memo.statsByVariableName[name];
-    if (!stat){
-      memo.statsByVariableName[name] = classLevel;
-      memo.classes[name] = classLevel;
-    } else if (!has(stat, 'level')){
-      // Stat is overriden by an attribute
-      return;
-    } else if (stat.level < classLevel.level) {
-      memo.statsByVariableName[name] = classLevel;
-      memo.classes[name] = classLevel;
-    }
-  });
-}
-
-function computeTotalLevel(memo){
-  let currentLevel = memo.statsByVariableName['level'];
-  if (!currentLevel || currentLevel.deactivatedByToggle){
-    currentLevel = {
-      value: 0,
-      dependencies: [],
-      computationDetails: {
-        builtIn: true,
-        computed: true,
-      }
-    };
-    memo.statsByVariableName['level'] = currentLevel;
-  }
-  // bail out if overriden by an attribute
-  if (!currentLevel.computationDetails.builtIn) return;
-  let level = 0;
-  for (let name in memo.classes){
-    let cls = memo.classes[name];
-    level += cls.level || 0;
-    if (cls._id){
-      currentLevel.dependencies = union(
-        currentLevel.dependencies,
-        [cls._id]
-      )
-    }
-    if (cls.dependencies){
-      currentLevel.dependencies = union(
-        currentLevel.dependencies,
-        cls.dependencies,
-      )
-    }
-  }
-  currentLevel.value = level;
-}

app/imports/api/creature/computation/engine/computeMemo.js

@@ -1,37 +0,0 @@
-import { each, forOwn } from 'lodash';
-import computeLevels from '/imports/api/creature/computation/engine/computeLevels.js';
-import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import computeEffect from '/imports/api/creature/computation/engine/computeEffect.js';
-import computeToggle from '/imports/api/creature/computation/engine/computeToggle.js';
-import computeEndStepProperty from '/imports/api/creature/computation/engine/computeEndStepProperty.js';
-import computeInlineCalculations from '/imports/api/creature/computation/engine/computeInlineCalculations.js';
-import computeConstant from '/imports/api/creature/computation/engine/computeConstant.js';
-
-export default function computeMemo(memo){
-  // Compute level
-  computeLevels(memo);
-  // Compute all constants that could be used
-  forOwn(memo.constantsById, constant => {
-    computeConstant (constant, memo);
-  });
-  // Compute all stats, even if they are overriden
-  forOwn(memo.statsById, stat => {
-    computeStat (stat, memo);
-  });
-  // Compute effects which didn't end up targeting a stat
-  each(memo.unassignedEffects, effect => {
-    computeEffect(effect, memo);
-  });
-  // Compute toggles which didn't already get computed by dependencies
-  forOwn(memo.togglesById, toggle => {
-    computeToggle(toggle, memo);
-  });
-  // Compute end step properties
-  forOwn(memo.endStepPropsById, prop => {
-    computeEndStepProperty(prop, memo);
-  });
-  // Compute inline calculations
-  forOwn(memo.propsById, prop => {
-    computeInlineCalculations(prop, memo);
-  });
-}

app/imports/api/creature/computation/engine/computeProficiency.js

@@ -1,23 +0,0 @@
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-
-export default function computeEffect(proficiency, memo){
-  if (proficiency.computationDetails.computed) return;
-  if (proficiency.computationDetails.busyComputing){
-    // Trying to compute this proficiency again while it is already computing.
-    // We must be in a dependency loop.
-    proficiency.computationDetails.computed = true;
-    proficiency.result = NaN;
-    proficiency.computationDetails.busyComputing = false;
-    proficiency.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', proficiency);
-    return;
-  }
-  // Before doing any work, mark this proficiency as busy
-  proficiency.computationDetails.busyComputing = true;
-
-  // Apply any toggles
-  applyToggles(proficiency, memo);
-
-  proficiency.computationDetails.computed = true;
-  proficiency.computationDetails.busyComputing = false;
-}

app/imports/api/creature/computation/engine/computeStat.js

@@ -1,161 +0,0 @@
-import combineStat from '/imports/api/creature/computation/engine/combineStat.js';
-import computeEffect from '/imports/api/creature/computation/engine/computeEffect.js';
-import EffectAggregator from '/imports/api/creature/computation/engine/EffectAggregator.js';
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { each, union, without } from 'lodash';
-
-export default function computeStat(stat, memo){
-  // If the stat is already computed, skip it
-  if (stat.computationDetails.computed) return;
-  if (stat.computationDetails.busyComputing){
-    // Trying to compute this stat again while it is already computing.
-    // We must be in a dependency loop.
-    stat.computationDetails.computed = true;
-    stat.value = NaN;
-    stat.computationDetails.busyComputing = false;
-    stat.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', stat);
-    return;
-  }
-  // Before doing any work, mark this stat as busy
-  stat.computationDetails.busyComputing = true;
-
-  let effects = stat.computationDetails.effects || [];
-  let proficiencies = stat.computationDetails.proficiencies || [];
-
-  // Get references to all the stats that share the variable name
-  let sameNameStats
-
-  if (stat.computationDetails.idsOfSameName){
-    sameNameStats = stat.computationDetails.idsOfSameName.map(
-      id => memo.propsById[id]
-    );
-  } else {
-    sameNameStats = [];
-  }
-
-  let allStats = [stat, ...sameNameStats];
-
-  // Decide which stat is the last active stat
-  // The last active stat is considered the cannonical stat
-  let lastActiveStat;
-  allStats.forEach(candidateStat => {
-    applyToggles(candidateStat, memo);
-    if (!candidateStat.inactive) lastActiveStat = candidateStat;
-    candidateStat.overridden = undefined;
-  });
-  if (!lastActiveStat){
-    delete memo.statsByVariableName[stat.variableName];
-    return;
-  }
-  // Make sure the active stat has all the effects and proficiencies
-  lastActiveStat.computationDetails.effects = effects;
-  lastActiveStat.computationDetails.proficiencies = proficiencies;
-
-  // Update the memo's stat with the chosen stat
-  memo.statsByVariableName[stat.variableName] = lastActiveStat;
-
-  // Recreate list of the non-cannonical stats
-  sameNameStats = without(allStats, lastActiveStat);
-
-  sameNameStats.forEach(statInstance => {
-    // Mark the non-cannonical stats as overridden
-    statInstance.overridden = true;
-
-    // Apply the cannonical damage
-    statInstance.damage = lastActiveStat.damage;
-  });
-
-  let baseDependencies = [];
-  allStats.forEach(statInstance => {
-    // Add this stat and its deps to the dependencies
-    baseDependencies = union(
-      baseDependencies,
-      [statInstance._id],
-      statInstance.dependencies,
-    );
-
-    // Apply all the base proficiencies
-    if (statInstance.baseProficiency && !statInstance.inactive){
-      proficiencies.push({
-        value: statInstance.baseProficiency,
-        stats: [statInstance.variableName],
-        type: 'proficiency',
-        dependencies: statInstance.overridden ?
-          union(statInstance.dependencies, [statInstance._id]) :
-          [],
-        computationDetails: {
-          computed: true,
-        }
-      });
-    }
-
-    // Compute each active stat's baseValue calculation and apply it
-    if (!statInstance.inactive) {
-      let {
-        result,
-        context,
-        dependencies
-      } = evaluateCalculation({
-        string: statInstance.baseValueCalculation,
-        prop: statInstance,
-        memo
-      });
-      result.value = +result.value;
-      if (!isNaN(result.value)){
-        statInstance.baseValue = result.value;
-      } else {
-        statInstance.baseValue = undefined;
-      }
-      statInstance.dependencies = union(statInstance.dependencies, dependencies);
-      if (context.errors.length){
-        statInstance.baseValueErrors = context.errors;
-      }
-      // Apply all the base values
-      if (Number.isFinite(statInstance.baseValue)){
-        effects.push({
-          operation: 'base',
-          calculation: statInstance.baseValueCalculation,
-          result: statInstance.baseValue,
-          stats: [statInstance.variableName],
-          dependencies: statInstance.overridden ?
-          union(statInstance.dependencies, [statInstance._id]) :
-          [],
-          computationDetails: {
-            computed: true,
-          },
-        });
-      }
-    }
-  });
-
-  // Compute and aggregate all the effects
-  let aggregator = new EffectAggregator();
-  let effectDeps = [];
-  each(effects, (effect) => {
-    // Compute
-    computeEffect(effect, memo);
-    if (effect.deactivatedByToggle) return;
-
-    // dependencies
-    if (effect._id) effectDeps = union(effectDeps, [effect._id]);
-    effectDeps = union(effectDeps, effect.dependencies);
-
-    // Add computed effect to aggregator
-    aggregator.addEffect(effect);
-  });
-
-  // Combine the effects into the stats
-  allStats.forEach(statInstance => {
-    // Conglomerate all the effects to compute the final stat values
-    combineStat(statInstance, aggregator, memo);
-    // Mark the stats as computed
-    statInstance.computationDetails.computed = true;
-    statInstance.computationDetails.busyComputing = false;
-    // Only the active stat instance depeneds on the effects
-    if (!statInstance.overridden){
-      statInstance.dependencies = union(statInstance.dependencies, effectDeps);
-    }
-  });
-}

app/imports/api/creature/computation/engine/computeToggle.js

@@ -1,55 +0,0 @@
-import evaluateCalculation from '/imports/api/creature/computation/engine/evaluateCalculation.js';
-import applyToggles from '/imports/api/creature/computation/engine/applyToggles.js';
-import { union } from 'lodash';
-
-export default function computeToggle(toggle, memo){
-  if (toggle.computationDetails.computed) return;
-  if (toggle.computationDetails.busyComputing){
-    // Trying to compute this effect again while it is already computing.
-    // We must be in a dependency loop.
-    toggle.computationDetails.computed = true;
-    toggle.result = false;
-    toggle.computationDetails.busyComputing = false;
-    toggle.computationDetails.error = 'dependencyLoop';
-    if (Meteor.isClient) console.warn('dependencyLoop', toggle);
-    return;
-  }
-  // Before doing any work, mark this toggle as busy
-  toggle.computationDetails.busyComputing = true;
-
-  // Apply any parent toggles
-  applyToggles(toggle, memo);
-
-  // Do work
-  delete toggle.errors;
-  if (toggle.enabled){
-    toggle.toggleResult = true;
-  } else if (toggle.disabled){
-    toggle.toggleResult = false;
-  } else if (!toggle.condition){
-    toggle.toggleResult = false;
-  } else if (Number.isFinite(+toggle.condition)){
-    toggle.toggleResult = !!+toggle.condition;
-  } else {
-    let {
-      result,
-      context,
-      dependencies,
-    } = evaluateCalculation({string: toggle.condition, prop: toggle, memo});
-    toggle.toggleResult = !!result.value;
-    toggle.dependencies = union(
-      toggle.dependencies,
-      dependencies,
-    );
-    if (context.errors.length){
-      toggle.errors = context.errors;
-    }
-  }
-  if (!toggle.toggleResult){
-    toggle.inactive = true;
-    toggle.deactivatedBySelf = true;
-    toggle.deactivatedByToggle = true;
-  }
-  toggle.computationDetails.computed = true;
-  toggle.computationDetails.busyComputing = false;
-}

app/imports/api/creature/computation/engine/evaluateCalculation.js

@@ -1,137 +0,0 @@
-import computeStat from '/imports/api/creature/computation/engine/computeStat.js';
-import { prettifyParseError, parse, CompilationContext } from '/imports/parser/parser.js';
-import SymbolNode from '/imports/parser/parseTree/SymbolNode.js';
-import AccessorNode from '/imports/parser/parseTree/AccessorNode.js';
-import ConstantNode from '/imports/parser/parseTree/ConstantNode.js';
-import ErrorNode from '/imports/parser/parseTree/ErrorNode.js';
-import findAncestorByType from '/imports/api/creature/computation/engine/findAncestorByType.js';
-import { union } from 'lodash';
-
-/* Convert a calculation into a constant output and errors*/
-export default function evaluateCalculation({
-  string,
-  prop,
-  memo,
-  fn = 'reduce',
-}){
-  let dependencies = [];
-  let context = new CompilationContext();
-  if (!string) return {
-    result: new ConstantNode({value: string, type: 'string'}),
-    context,
-    dependencies,
-  };
-  if (typeof string !== 'string'){
-    string = string.toString();
-  }
-  // Parse the string
-  let calc;
-  try {
-    calc = parse(string);
-  } catch (e) {
-    let error = prettifyParseError(e);
-    return {
-      result: new ErrorNode({context, error}),
-      context,
-      dependencies,
-    };
-  }
-
-  // Replace constants with their parsed constant
-  let replaceResults = replaceConstants({
-    calc, memo, prop, dependencies, context
-  });
-  dependencies = replaceResults.dependencies;
-  calc = replaceResults.calc;
-  if (replaceResults.failed){
-    return {
-      result: new ConstantNode({value: string, type: 'string'}),
-      context,
-      dependencies,
-    };
-  }
-
-  // Ensure all symbol nodes are defined and computed
-  dependencies = computeSymbols({calc, memo, prop, dependencies})
-
-  // Evaluate
-  let result = calc[fn](memo.statsByVariableName, context);
-  return {result, context, dependencies};
-}
-
-// Replace constants in the calc with the right ParseNodes
-function replaceConstants({calc, memo, prop, dependencies, context}){
-  let constFailed = [];
-  calc = calc.replaceNodes(node => {
-    if (!(node instanceof SymbolNode)) return;
-    let stat, constant;
-    if (node.name[0] !== '#'){
-      stat = memo.statsByVariableName[node.name]
-      constant = memo.constantsByVariableName[node.name];
-    } else if (node.name === '#constant'){
-      constant = findAncestorByType({type: 'constant', prop, memo});
-    }
-    // replace constants that aren't overridden by stats or disabled by a toggle
-    if (constant && !constant.deactivatedByToggle && !stat){
-      dependencies = union(dependencies, [
-        constant._id,
-        ...constant.dependencies
-      ]);
-      // Fail if the constant has errors
-      if (constant.errors && constant.errors.length){
-        constFailed.push(node.name);
-        return;
-      }
-      let parsedConstantNode;
-      try {
-        parsedConstantNode = parse(constant.calculation);
-      } catch(e){
-        constFailed.push(node.name);
-        return;
-      }
-      if (!parsedConstantNode) constFailed.push(node.name);
-      return parsedConstantNode;
-    }
-  });
-  constFailed.forEach(name => {
-    context.storeError({
-      type: 'error',
-      message: `${name} is a constant property with parsing errors`
-    });
-  });
-  let failed = !!constFailed.length;
-  if (failed){
-    calc = new ErrorNode({error: 'Failed to replace constants'});
-  }
-  return { failed, dependencies, calc };
-}
-
-  // Ensure all symbol nodes are defined and computed
-function computeSymbols({calc, memo, prop, dependencies}){
-  calc.traverse(node => {
-    if (node instanceof SymbolNode || node instanceof AccessorNode){
-      let stat;
-      // References up the tree start with #
-      if (node.name[0] === '#'){
-        stat = findAncestorByType({type: node.name.slice(1), prop, memo});
-        memo.statsByVariableName[node.name] = stat;
-      } else {
-        stat = memo.statsByVariableName[node.name];
-      }
-      if (stat && stat.computationDetails && !stat.computationDetails.computed){
-        computeStat(stat, memo);
-      }
-      if (stat){
-        if (stat.dependencies){
-          dependencies = union(dependencies, [
-            stat._id || node.name,
-            ...stat.dependencies
-          ]);
-        } else {
-          dependencies = union(dependencies, [stat._id || node.name]);
-        }
-      }
-    }
-  });
-  return dependencies;
-}

app/imports/api/creature/computation/engine/findAncestorByType.js

@@ -1,10 +0,0 @@
-export default function findAncestorByType({type, prop, memo}){
-  if (!prop || !prop.ancestors) return;
-  let ancestor;
-  for (let i = prop.ancestors.length - 1; i >= 0; i--){
-    ancestor = memo.propsById[prop.ancestors[i].id];
-    if (ancestor && ancestor.type === type){
-      return ancestor;
-    }
-  }
-}

app/imports/api/creature/computation/engine/getComputationProperties.js

@@ -1,24 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getComputationProperties(creatureId){
-  // Find all the relevant properties
-  return CreatureProperties.find({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    $or: [
-      // All active properties
-      {inactive: {$ne: true}},
-      // Unless they were deactivated because of a toggle
-      {deactivatedByToggle: true},
-    ]
-  }, {
-    // Filter out fields never used by calculations
-    fields: {
-      icon: 0,
-    },
-    // Obey tree order
-    sort: {
-      order: 1,
-    }
-  }).fetch();
-}

app/imports/api/creature/computation/engine/getDependentProperties.js

@@ -1,51 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { union } from 'lodash';
-
-export default function getDependentProperties({
-  creatureId,
-  propertyIds,
-  propertiesDependedAponIds,
- }){
-  // find ids of all dependant toggles that have conditions, even if inactive
-  let toggleIds = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    type: 'toggle',
-    removed: {$ne: true},
-    condition: { $exists: true },
-    dependencies: {$in: propertyIds},
-  }, {
-    fields: {_id: 1},
-  }).map(t => t._id);
-  // Find all the dependant properties
-  let props = CreatureProperties.find({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    dependencies: {$in: propertyIds},
-    $or: [
-      // All active properties
-      {inactive: {$ne: true}},
-      // All active and inactive toggles with conditions
-      // Same as {$in: toggleIds}, but should be slightly faster
-      {type: 'toggle', condition: { $exists: true }},
-      // All decendents of the above toggles
-      {'ancestors.id': {$in: toggleIds}},
-    ]
-  }, { fields: {_id: 1, dependencies: 1} }).fetch();
-  // Add all the properties that changing props depend on, but haven't yet been
-  // included to make an array of every property we need
-  let allConnectedPropIds = [...propertyIds, ...propertiesDependedAponIds];
-  props.forEach(prop => {
-    allConnectedPropIds = union(
-      allConnectedPropIds,
-      prop.dependencies,
-      [prop._id]);
-  });
-  // Add on all the properties and the objects they depend apon
-  return CreatureProperties.find({
-    _id: {$in: allConnectedPropIds}
-  }, {
-    // Ignore fields not used in computations
-    fields: {icon: 0},
-    sort: {order: 1},
-  }).fetch();
-}

app/imports/api/creature/computation/engine/writeAlteredProperties.js

@@ -1,118 +0,0 @@
-import { Meteor } from 'meteor/meteor'
-import { isEqual, forOwn } from 'lodash';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import propertySchemasIndex from '/imports/api/properties/computedOnlyPropertySchemasIndex.js';
-
-export default function writeAlteredProperties(memo){
-  let bulkWriteOperations = [];
-  // Loop through all properties on the memo
-  forOwn(memo.propsById, changed => {
-    let schema = propertySchemasIndex[changed.type];
-    if (!schema){
-      console.warn('No schema for ' + changed.type);
-      return;
-    }
-    let id = changed._id;
-    let op = undefined;
-    let original = memo.originalPropsById[id];
-    let keys = [
-      'dependencies',
-      'inactive',
-      'deactivatedBySelf',
-      'deactivatedByAncestor',
-      'deactivatedByToggle',
-      'damage',
-      ...schema.objectKeys(),
-    ];
-    op = addChangedKeysToOp(op, keys, original, changed);
-    if (op){
-      bulkWriteOperations.push(op);
-    }
-  });
-  writePropertiesSequentially(bulkWriteOperations);
-}
-
-function addChangedKeysToOp(op, keys, original, changed) {
-  // Loop through all keys that can be changed by computation
-  // and compile an operation that sets all those keys
-  for (let key of keys){
-    if (!isEqual(original[key], changed[key])){
-      if (!op) op = newOperation(original._id, changed.type);
-      let value = changed[key];
-      if (value === undefined){
-        // Unset values that become undefined
-        addUnsetOp(op, key);
-      } else {
-        // Set values that changed to something else
-        addSetOp(op, key, value);
-      }
-    }
-  }
-  return op;
-}
-
-function newOperation(_id, type){
-  let newOp = {
-    updateOne: {
-      filter: {_id},
-      update: {},
-    }
-  };
-  if (Meteor.isClient){
-    newOp.type = type;
-  }
-  return newOp;
-}
-
-function addSetOp(op, key, value){
-  if (op.updateOne.update.$set){
-    op.updateOne.update.$set[key] = value;
-  } else {
-    op.updateOne.update.$set = {[key]: value};
-  }
-}
-
-function addUnsetOp(op, key){
-  if (op.updateOne.update.$unset){
-    op.updateOne.update.$unset[key] = 1;
-  } else {
-    op.updateOne.update.$unset = {[key]: 1};
-  }
-}
-
-// We use this instead of bulkWriteProperties because it functions with latency
-// compensation without needing to roll back changes, which causes multiple
-// expensive redraws of the character sheet
-function writePropertiesSequentially(bulkWriteOps){
-  bulkWriteOps.forEach(op => {
-    let updateOneOrMany = op.updateOne || op.updateMany;
-    CreatureProperties.update(updateOneOrMany.filter, updateOneOrMany.update, {
-      // The bulk code is bypassing validation, so do the same here
-      // selector: {type: op.type} // include this if bypass is off
-      bypassCollection2: true,
-    });
-  });
-}
-
-// This is more efficient on the database, but significantly less efficient
-// in the UI because of incompatibility with latency compensation. If the
-// duplicate redraws can be fixed, this is a strictly better way of processing
-// writes
-function bulkWriteProperties(bulkWriteOps){
-  if (!bulkWriteOps.length) return;
-  // bulkWrite is only available on the server
-  if (Meteor.isServer){
-    CreatureProperties.rawCollection().bulkWrite(
-      bulkWriteOps,
-      {ordered : false},
-      function(e){
-        if (e) {
-          console.error('Bulk write failed: ');
-          console.error(e);
-        }
-      }
-    );
-  } else {
-    writePropertiesSequentially(bulkWriteOps);
-  }
-}

app/imports/api/creature/computation/engine/writeCreatureVariables.js

@@ -1,59 +0,0 @@
-import { pick, forOwn } from 'lodash';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import VERSION from '/imports/constants/VERSION.js';
-
-export default function writeCreatureVariables(memo, creatureId, fullRecompute = true) {
-  const fields = [
-    'ability',
-    'abilityMod',
-    'advantage',
-    'attributeType',
-    'baseProficiency',
-    'baseValue',
-    'calculation',
-    'conditionalBenefits',
-    'currentValue',
-    'damage',
-    'decimal',
-    'fail',
-    'level',
-    'modifier',
-    'name',
-    'passiveBonus',
-    'proficiency',
-    'reset',
-    'resetMultiplier',
-    'rollBonuses',
-    'skillType',
-    'spellSlotLevelValue',
-    'type',
-    'value',
-  ];
-
-  if (fullRecompute){
-    memo.creatureVariables = {};
-    forOwn(memo.statsByVariableName, (stat, variableName) => {
-      // Don't save context variables
-      if (variableName[0] === '#') return;
-      let condensedStat = pick(stat, fields);
-      memo.creatureVariables[variableName] = condensedStat;
-    });
-    forOwn(memo.constantsByVariableName, (stat, variableName) => {
-      let condensedStat = pick(stat, fields);
-      if (!memo.creatureVariables[variableName]){
-        memo.creatureVariables[variableName] = condensedStat;
-      }
-    });
-    Creatures.update(creatureId, {$set: {
-      variables: memo.creatureVariables,
-      computeVersion: VERSION,
-    }});
-  } else {
-    let $set = {};
-    forOwn(memo.statsByVariableName, (stat, variableName) => {
-      let condensedStat = pick(stat, fields);
-      $set[`variables.${variableName}`] = condensedStat;
-    });
-    Creatures.update(creatureId, {$set});
-  }
-}

app/imports/api/creature/computation/methods/recomputeCreature.js

@@ -1,120 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/creature/creatures/creaturePermissions.js';
-import ComputationMemo from '/imports/api/creature/computation/engine/ComputationMemo.js';
-import getComputationProperties from '/imports/api/creature/computation/engine/getComputationProperties.js';
-import computeMemo from '/imports/api/creature/computation/engine/computeMemo.js';
-import writeAlteredProperties from '/imports/api/creature/computation/engine/writeAlteredProperties.js';
-import writeCreatureVariables from '/imports/api/creature/computation/engine/writeCreatureVariables.js';
-import { recomputeDamageMultipliersById } from '/imports/api/creature/denormalise/recomputeDamageMultipliers.js';
-import recomputeSlotFullness from '/imports/api/creature/denormalise/recomputeSlotFullness.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import getDependentProperties from '/imports/api/creature/computation/engine/getDependentProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-
-export const recomputeCreature = new ValidatedMethod({
-
-  name: 'creatures.recomputeCreature',
-
-  validate: new SimpleSchema({
-    charId: { type: String }
-  }).validator(),
-
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 5,
-    timeInterval: 5000,
-  },
-
-  run({charId}) {
-    let creature = Creatures.findOne(charId);
-    // Permission
-    assertEditPermission(creature, this.userId);
-    // Work, call this direcly if you are already in a method that has checked
-    // for permission to edit a given character
-    recomputeCreatureById(charId);
-  },
-
-});
-
-export function recomputeCreatureById(creatureId){
-  let creature = Creatures.findOne(creatureId);
-  recomputeCreatureByDoc(creature);
-}
-
-/**
- * This function is the heart of DiceCloud. It recomputes a creature's stats,
- * distilling down effects and proficiencies into the final stats that make up
- * a creature.
- *
- * Essentially this is a depth first tree traversal algorithm that computes
- * stats' dependencies before computing stats themselves, while detecting
- * dependency loops.
- *
- * At the moment it makes no effort to limit recomputation to just what was
- * changed.
- *
- * Attempting to implement dependency management to limit recomputation to just
- * change affected stats should only happen as a last resort, when this function
- * can no longer be performed more efficiently, and server resources can not be
- * expanded to meet demand.
- *
- * A brief overview:
- * - Fetch the stats of the creature and add them to
- *   an object for quick lookup
- * - Fetch the effects and proficiencies which apply to each stat and store them with the stat
- * - Fetch the class levels and store them as well
- * - Mark each stat and effect as uncomputed
- * - Iterate over each stat in order and compute it
- *   - If the stat is already computed, skip it
- *   - If the stat is busy being computed, we are in a dependency loop, make it NaN and mark computed
- *   - Mark the stat as busy computing
- *   - Iterate over each effect which applies to the attribute
- *     - If the effect is not computed compute it
- *       - If the effect relies on another attribute, get its computed value
- *       - Recurse if that attribute is uncomputed
- *     - apply the effect to the attribute
- *   - Conglomerate all the effects to compute the final stat values
- *   - Mark the stat as computed
- * - Write the computed results back to the database
- */
-export function recomputeCreatureByDoc(creature){
-  const creatureId = creature._id;
-  let props = getComputationProperties(creatureId);
-  let computationMemo = new ComputationMemo(props, creature);
-  computeMemo(computationMemo);
-  writeAlteredProperties(computationMemo);
-  writeCreatureVariables(computationMemo, creatureId);
-  recomputeDamageMultipliersById(creatureId);
-  recomputeSlotFullness(creatureId);
-  return computationMemo;
-}
-
-export function recomputePropertyDependencies(property){
-  let creature = getRootCreatureAncestor(property);
-  recomputeCreatureByDependencies({
-    creature,
-    propertyIds: [property._id],
-    propertiesDependedAponIds: property.dependencies,
-  });
-}
-
-export function recomputeCreatureByDependencies({
-  creature,
-  propertyIds,
-  propertiesDependedAponIds
-}){
-  let props = getDependentProperties({
-    creatureId: creature._id,
-    propertyIds,
-    propertiesDependedAponIds,
-  });
-  let computationMemo = new ComputationMemo(props, creature);
-  computeMemo(computationMemo);
-  writeAlteredProperties(computationMemo);
-  writeCreatureVariables(computationMemo, creature._id, false)
-  recomputeInactiveProperties(creature._id);
-  return computationMemo;
-}

app/imports/api/creature/creatureFolders/CreatureFolders.js

@@ -1,26 +1,28 @@
 import SimpleSchema from 'simpl-schema';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS';
 
 let CreatureFolders = new Mongo.Collection('creatureFolders');
 
 let creatureFolderSchema = new SimpleSchema({
-	name: {
-		type: String,
-		trim: false,
-		optional: true,
-	},
-	creatures: {
-		type: Array,
-		defaultValue: [],
-	},
-	'creatures.$': {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
-	},
-	owner: {
-		type: String,
-		regEx: SimpleSchema.RegEx.Id,
+  name: {
+    type: String,
+    trim: false,
+    optional: true,
+    max: STORAGE_LIMITS.name,
+  },
+  creatures: {
+    type: Array,
+    defaultValue: [],
+  },
+  'creatures.$': {
+    type: String,
+    max: 32,
+  },
+  owner: {
+    type: String,
+    max: 32,
     index: 1,
-	},
+  },
   archived: {
     type: Boolean,
     optional: true,
@@ -33,5 +35,5 @@ let creatureFolderSchema = new SimpleSchema({
 
 CreatureFolders.attachSchema(creatureFolderSchema);
 
-import '/imports/api/creature/creatureFolders/methods.js/index.js';
+import '/imports/api/creature/creatureFolders/methods.js/index';
 export default CreatureFolders;

app/imports/api/creature/creatureFolders/methods.js/index.js

@@ -1,4 +1,4 @@
-import '/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js';
-import '/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js';
-import '/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js';
-import '/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js';
+import '/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder';
+import '/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName';
+import '/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder';
+import '/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder';

app/imports/api/creature/creatureFolders/methods.js/insertCreatureFolder.js

@@ -1,4 +1,4 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
@@ -15,23 +15,23 @@ const insertCreatureFolder = new ValidatedMethod({
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('creatureFolders.methods.insert.denied',
-      'You need to be logged in to insert a folder');
+        'You need to be logged in to insert a folder');
     }
     // Limit folders to 50 per user
     let existingFolders = CreatureFolders.find({
       owner: userId
     }, {
-      fields: {order: 1},
-      sort: {order :-1}
+      fields: { order: 1 },
+      sort: { left: -1 }
     });
-    if (existingFolders.count() >= 50){
+    if (existingFolders.count() >= 50) {
       throw new Meteor.Error('creatureFolders.methods.insert.denied',
-      'You can not have more than 50 folders');
+        'You can not have more than 50 folders');
     }
     // Make the new folder the last in the order
     let order = 0;
     let lastFolder = existingFolders.fetch()[0];
-    if (lastFolder){
+    if (lastFolder) {
       order = (lastFolder.order || 0) + 1;
     }
     // Insert

app/imports/api/creature/creatureFolders/methods.js/moveCreatureToFolder.js

@@ -1,4 +1,4 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
@@ -10,33 +10,33 @@ const moveCreatureToFolder = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureId, folderId}) {
+  run({ creatureId, folderId }) {
     // Ensure logged in
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to remove a folder');
+        'You need to be logged in to remove a folder');
     }
     // Check that this folder is owned by the user
-    if (folderId){
+    if (folderId) {
       let existingFolder = CreatureFolders.findOne(folderId);
-      if (existingFolder.owner !== userId){
+      if (existingFolder.owner !== userId) {
         throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-        'This folder does not belong to you');
+          'This folder does not belong to you');
       }
     }
     // Remove from other folders
     CreatureFolders.update({
       owner: userId
     }, {
-      $pull: {creatures: creatureId},
+      $pull: { creatures: creatureId },
     }, {
       multi: true,
     });
-    if (folderId){
+    if (folderId) {
       // Add to this folder
       CreatureFolders.update(folderId, {
-        $addToSet: {creatures: creatureId},
+        $addToSet: { creatures: creatureId },
       });
     }
   },

app/imports/api/creature/creatureFolders/methods.js/removeCreatureFolder.js

@@ -1,4 +1,4 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
@@ -10,18 +10,18 @@ const removeCreatureFolder = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id}) {
+  run({ _id }) {
     // Ensure logged in
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to remove a folder');
+        'You need to be logged in to remove a folder');
     }
     // Check that this folder is owned by the user
     let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
+    if (existingFolder.owner !== userId) {
       throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'This folder does not belong to you');
+        'This folder does not belong to you');
     }
     // Remove
     return CreatureFolders.remove(_id);

app/imports/api/creature/creatureFolders/methods.js/reorderCreatureFolder.js

@@ -1,4 +1,4 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
@@ -10,31 +10,31 @@ const reorderCreatureFolder = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, order}) {
+  run({ _id, order }) {
     // Ensure logged in
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('creatureFolders.methods.reorder.denied',
-      'You need to be logged in to reorder a folder');
+        'You need to be logged in to reorder a folder');
     }
     // Check that this folder is owned by the user
     let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
+    if (existingFolder.owner !== userId) {
       throw new Meteor.Error('creatureFolders.methods.reorder.denied',
-      'This folder does not belong to you');
+        'This folder does not belong to you');
     }
     // First give it the new order, it should end in 0.5 putting it between two other docs
-    CreatureFolders.update(_id, {$set: {order}});
+    CreatureFolders.update(_id, { $set: { order } });
     this.unblock();
     // Reorder all the folders with integer numbers in this new order
     CreatureFolders.find({
       owner: userId
     }, {
-      fields: {order: 1,},
-      sort: {order: -1}
+      fields: { order: 1, },
+      sort: { order: 1 }
     }).forEach((folder, index) => {
-      if (folder.order !== index){
-        CreatureFolders.update(_id, {$set: {order: index}})
+      if (folder.order !== index) {
+        CreatureFolders.update(_id, { $set: { order: index } })
       }
     });
   },

app/imports/api/creature/creatureFolders/methods.js/updateCreatureFolderName.js

@@ -1,4 +1,4 @@
-import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders.js';
+import CreatureFolders from '/imports/api/creature/creatureFolders/CreatureFolders';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 
@@ -10,21 +10,21 @@ const updateCreatureFolderName = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, name}) {
+  run({ _id, name }) {
     // Ensure logged in
     let userId = this.userId;
     if (!userId) {
       throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'You need to be logged in to update a folder');
+        'You need to be logged in to update a folder');
     }
     // Check that this folder is owned by the user
     let existingFolder = CreatureFolders.findOne(_id);
-    if (existingFolder.owner !== userId){
+    if (existingFolder.owner !== userId) {
       throw new Meteor.Error('creatureFolders.methods.updateName.denied',
-      'This folder does not belong to you');
+        'This folder does not belong to you');
     }
     // Update
-    return CreatureFolders.update(_id, {$set: {name}});
+    return CreatureFolders.update(_id, { $set: { name } });
   },
 });
 

app/imports/api/creature/creatureProperties/CreatureProperties.js

@@ -1,90 +0,0 @@
-import { Mongo } from 'meteor/mongo';
-import SimpleSchema from 'simpl-schema';
-import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema.js';
-import ChildSchema from '/imports/api/parenting/ChildSchema.js';
-import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema.js';
-import propertySchemasIndex from '/imports/api/properties/computedPropertySchemasIndex.js';
-import { storedIconsSchema } from '/imports/api/icons/Icons.js';
-
-let CreatureProperties = new Mongo.Collection('creatureProperties');
-
-let CreaturePropertySchema = new SimpleSchema({
-	type: {
-    type: String,
-    allowedValues: Object.keys(propertySchemasIndex),
-  },
-	tags: {
-		type: Array,
-		defaultValue: [],
-	},
-	'tags.$': {
-		type: String,
-	},
-	disabled: {
-		type: Boolean,
-		optional: true,
-	},
-  icon: {
-    type: storedIconsSchema,
-    optional: true,
-  },
-  // Denormalised flag if this property is inactive on the sheet for any reason
-  // Including being disabled, or a decendent of a disabled property
-  inactive: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-  },
-  // Denormalised flag if this property was made inactive by an inactive
-  // ancestor. True if this property has an inactive ancestor even if this
-  // property is itself inactive
-  deactivatedByAncestor: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-  },
-  // Denormalised flag if this property was made inactive because of its own
-  // state
-  deactivatedBySelf: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-  },
-  // Denormalised flag if this property was made inactive because of a toggle
-  // calculation. Either an ancestor toggle calculation or its own.
-  deactivatedByToggle: {
-    type: Boolean,
-    optional: true,
-    index: 1,
-  },
-  // Denormalised list of all properties or creatures this property depends on
-  dependencies: {
-    type: Array,
-    defaultValue: [],
-    index: 1,
-  },
-  'dependencies.$': {
-    type: String,
-  },
-});
-
-for (let key in propertySchemasIndex){
-	let schema = new SimpleSchema({});
-	schema.extend(propertySchemasIndex[key]);
-	schema.extend(CreaturePropertySchema);
-  schema.extend(ColorSchema);
-	schema.extend(ChildSchema);
-	schema.extend(SoftRemovableSchema);
-	CreatureProperties.attachSchema(schema, {
-		selector: {type: key}
-	});
-}
-
-import '/imports/api/creature/creatureProperties/methods/index.js';
-import '/imports/api/creature/actions/doAction.js';
-import '/imports/api/creature/actions/castSpellWithSlot.js';
-
-export default CreatureProperties;
-export {
-	CreaturePropertySchema,
-};

app/imports/api/creature/creatureProperties/CreatureProperties.ts

@@ -0,0 +1,174 @@
+import SimpleSchema from 'simpl-schema';
+import ColorSchema from '/imports/api/properties/subSchemas/ColorSchema';
+import ChildSchema from '/imports/api/parenting/ChildSchema';
+import SoftRemovableSchema from '/imports/api/parenting/SoftRemovableSchema';
+import propertySchemasIndex from '/imports/api/properties/computedPropertySchemasIndex';
+import { storedIconsSchema } from '/imports/api/icons/Icons';
+import STORAGE_LIMITS from '/imports/constants/STORAGE_LIMITS';
+import { ConvertToUnion, InferType, TypedSimpleSchema } from '/imports/api/utility/TypedSimpleSchema';
+import { Simplify } from 'type-fest';
+import type { PropertyType } from '/imports/api/properties/PropertyType.type';
+
+const PreComputeCreaturePropertySchema = TypedSimpleSchema.from({
+  _id: {
+    type: String,
+    max: 32,
+  },
+  _migrationError: {
+    type: String,
+    optional: true,
+  },
+  type: {
+    type: String,
+    allowedValues: Object.keys(propertySchemasIndex),
+  },
+  tags: {
+    type: Array,
+    defaultValue: [],
+    maxCount: STORAGE_LIMITS.tagCount,
+  },
+  'tags.$': {
+    type: String,
+    max: STORAGE_LIMITS.tagLength,
+  },
+  disabled: {
+    type: Boolean,
+    optional: true,
+  },
+  icon: {
+    type: storedIconsSchema,
+    optional: true,
+    max: STORAGE_LIMITS.icon,
+  },
+  // Reference to the library node that this property was copied from
+  libraryNodeId: {
+    type: String,
+    max: 32,
+    optional: true,
+  },
+  // Fill more than one quantity in a slot, like feats and ability score
+  // improvements, filtered out of UI if there isn't space in quantityExpected
+  slotQuantityFilled: {
+    type: SimpleSchema.Integer,
+    optional: true, // Undefined implies 1
+  },
+});
+
+const DenormalisedOnlyCreaturePropertySchema = TypedSimpleSchema.from({
+  // Denormalised flag if this property is inactive on the sheet for any reason
+  // Including being disabled, or a descendant of a disabled property
+  inactive: {
+    type: Boolean,
+    optional: true,
+    removeBeforeCompute: true,
+  },
+  // Denormalised flag if this property was made inactive by an inactive
+  // ancestor. True if this property has an inactive ancestor even if this
+  // property is itself inactive
+  deactivatedByAncestor: {
+    type: Boolean,
+    optional: true,
+    removeBeforeCompute: true,
+  },
+  // Denormalised flag if this property was made inactive because of its own
+  // state
+  deactivatedBySelf: {
+    type: Boolean,
+    optional: true,
+    removeBeforeCompute: true,
+  },
+  // Denormalised flag if this property was made inactive because of a toggle
+  // calculation. Either an ancestor toggle calculation or its own.
+  deactivatedByToggle: {
+    type: Boolean,
+    optional: true,
+    removeBeforeCompute: true,
+  },
+  deactivatingToggleId: {
+    type: String,
+    max: 32,
+    optional: true,
+    removeBeforeCompute: true,
+  },
+  // Triggers that fire when this property is applied
+  'triggerIds': {
+    type: Object,
+    optional: true,
+    removeBeforeCompute: true,
+  },
+  'triggerIds.before': {
+    type: Array,
+    optional: true,
+  },
+  'triggerIds.before.$': {
+    type: String,
+    max: 32,
+  },
+  'triggerIds.after': {
+    type: Array,
+    optional: true,
+  },
+  'triggerIds.after.$': {
+    type: String,
+    max: 32,
+  },
+  'triggerIds.afterChildren': {
+    type: Array,
+    optional: true,
+  },
+  'triggerIds.afterChildren.$': {
+    type: String,
+    max: 32,
+  },
+  // When this is true on any property, the creature needs to be recomputed
+  dirty: {
+    type: Boolean,
+    // Default to true because new properties cause a recomputation
+    defaultValue: true,
+    optional: true,
+  },
+});
+
+const CreaturePropertySchema = PreComputeCreaturePropertySchema.extend(DenormalisedOnlyCreaturePropertySchema);
+
+export type CreaturePropertyTypes = {
+  [T in PropertyType]: Simplify<
+    { type: T }
+    & InferType<typeof propertySchemasIndex[T]>
+  > & Simplify<
+    Exclude<InferType<typeof CreaturePropertySchema>, 'type'>
+    & InferType<typeof ColorSchema>
+    & InferType<typeof ChildSchema>
+    & InferType<typeof SoftRemovableSchema>
+  >
+}
+
+export type CreatureProperty = Simplify<ConvertToUnion<CreaturePropertyTypes>>;
+
+const CreatureProperties = new Mongo.Collection<CreatureProperty>('creatureProperties');
+
+const genericCreaturePropertySchema = TypedSimpleSchema.from({})
+  .extend(CreaturePropertySchema)
+  .extend(ColorSchema)
+  .extend(ChildSchema)
+  .extend(SoftRemovableSchema);
+
+// Attach the default schema
+CreatureProperties.attachSchema(genericCreaturePropertySchema);
+
+// Attach the schemas for each type
+let key: keyof typeof propertySchemasIndex;
+for (key in propertySchemasIndex) {
+  const schema = TypedSimpleSchema.from({})
+    .extend(propertySchemasIndex[key])
+    .extend(genericCreaturePropertySchema)
+  CreatureProperties.attachSchema(schema, {
+    selector: { type: key }
+  });
+}
+
+export default CreatureProperties;
+export {
+  DenormalisedOnlyCreaturePropertySchema,
+  CreaturePropertySchema,
+};

app/imports/api/creature/creatureProperties/getRootCreatureAncestor.js

@@ -1,5 +1,5 @@
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
+import { getCreature } from '/imports/api/engine/loadCreatures';
 
-export default function getRootCreatureAncestor(property){
-  return Creatures.findOne(property.ancestors[0].id);
+export default function getRootCreatureAncestor(property) {
+  return getCreature(property.root.id);
 }

app/imports/api/creature/creatureProperties/methods/adjustQuantity.js

@@ -1,11 +1,9 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
 
 const adjustQuantity = new ValidatedMethod({
   name: 'creatureProperties.adjustQuantity',
@@ -22,44 +20,40 @@ const adjustQuantity = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, operation, value}) {
+  run({ _id, operation, value }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
-		assertEditPermission(rootCreature, this.userId);
+    assertEditPermission(rootCreature, this.userId);
 
     // Do work
-    adjustQuantityWork({property, operation, value});
-
-    // Changing quantity does not change dependencies, but recomputing the
-    // inventory changes many deps at once, so recompute fully
-    recomputeCreatureByDoc(rootCreature);
-    recomputeInventory(rootCreature._id);
+    adjustQuantityWork({ property, operation, value });
   },
 });
 
-export function adjustQuantityWork({property, operation, value}){
+export function adjustQuantityWork({ property, operation, value }) {
   // Check if property has quantity
   let schema = CreatureProperties.simpleSchema(property);
-  if (!schema.allowsKey('quantity')){
+  if (!schema.allowsKey('quantity')) {
     throw new Meteor.Error(
       'Adjust quantity failed',
       `Property of type "${property.type}" doesn't have a quantity`
     );
   }
-  if (operation === 'set'){
+  if (operation === 'set') {
     CreatureProperties.update(property._id, {
-      $set: {quantity: value}
+      $set: { quantity: value, dirty: true }
     }, {
       selector: property
     });
-  } else if (operation === 'increment'){
+  } else if (operation === 'increment') {
     // value here is 'damage'
     value = -value;
     let currentQuantity = property.quantity;
     if (currentQuantity + value < 0) value = -currentQuantity;
     CreatureProperties.update(property._id, {
-      $inc: {quantity: value}
+      $inc: { quantity: value },
+      $set: { dirty: true }
     }, {
       selector: property
     });

app/imports/api/creature/creatureProperties/methods/copyPropertyToLibrary.js

@@ -0,0 +1,182 @@
+import SimpleSchema from 'simpl-schema';
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import LibraryNodes from '/imports/api/library/LibraryNodes';
+import { RefSchema } from '/imports/api/parenting/ChildSchema';
+import {
+  assertEditPermission,
+  assertDocEditPermission,
+  assertCopyPermission
+} from '/imports/api/sharing/sharingPermissions';
+import {
+  fetchDocByRef,
+  getFilter,
+  renewDocIds
+} from '/imports/api/parenting/parentingFunctions';
+import { rebuildNestedSets } from '/imports/api/parenting/parentingFunctions';
+import Libraries from '/imports/api/library/Libraries';
+const DUPLICATE_CHILDREN_LIMIT = 500;
+
+const copyPropertyToLibrary = new ValidatedMethod({
+  name: 'creatureProperties.copyPropertyToLibrary',
+  validate: new SimpleSchema({
+    propId: {
+      type: String,
+      max: 32,
+    },
+    parentRef: {
+      type: RefSchema,
+    },
+    order: {
+      type: Number,
+      optional: true,
+    },
+  }).validator(),
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 1,
+    timeInterval: 5000,
+  },
+  run({ propId, parentRef, order }) {
+    // get the new ancestry for the properties
+    const parentDoc = fetchDocByRef(parentRef);
+
+    // Check permission to edit the destination
+    let rootLibrary;
+    if (parentRef.collection === 'libraries') {
+      rootLibrary = parentDoc;
+    } else if (parentRef.collection === 'libraryNodes') {
+      rootLibrary = Libraries.findOne(parentDoc.root.id)
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
+    assertEditPermission(rootLibrary, this.userId);
+
+    const insertedRootNode = insertNodeFromProperty(propId, order, this);
+
+    // Tree structure changed by inserts, reorder the tree
+    rebuildNestedSets(LibraryNodes, rootLibrary._id);
+
+    // Return the docId of the inserted root property
+    return insertedRootNode?._id;
+  },
+});
+
+function insertNodeFromProperty(propId, order, method) {
+  // Fetch the property and its descendants, provided they have not been
+  // removed
+  let prop = CreatureProperties.findOne({
+    _id: propId,
+    removed: { $ne: true },
+  });
+  if (!prop) {
+    if (Meteor.isClient) return;
+    else {
+      throw new Meteor.Error(
+        'Insert property from library failed',
+        `No property with id '${propId}' was found`
+      );
+    }
+  }
+
+  // Make sure we can edit this property
+  assertDocEditPermission(prop, method.userId);
+
+  let oldParentId = prop.parentId;
+  const propCursor = CreatureProperties.find({
+    ...getFilter.descendants(prop),
+    removed: { $ne: true },
+  });
+
+  // Make sure there aren't too many descendants
+  if (propCursor.count() > DUPLICATE_CHILDREN_LIMIT) {
+    throw new Meteor.Error('Copy children limit',
+      `The property has over ${DUPLICATE_CHILDREN_LIMIT} descendants and cannot be copied`);
+  }
+
+  let props = propCursor.fetch();
+
+  // The root prop is first in the array of props
+  // It must get the first generated ID to prevent flickering
+  props = [prop, ...props];
+
+  // If the docs came from a library, that library must consent to this user copying their
+  // properties
+  assertSourceLibraryCopyPermission(props, method);
+
+  // Give the docs new IDs without breaking internal references
+  renewDocIds({
+    docArray: props,
+    collectionMap: { 'creatureProperties': 'libraryNodes' }
+  });
+
+  // Order the root node
+  prop.left = Number.MAX_SAFE_INTEGER - 1;
+  prop.right = Number.MAX_SAFE_INTEGER;
+
+  // Clean the props
+  props = cleanProps(props);
+
+  // Insert the props as library nodes
+  LibraryNodes.batchInsert(props);
+  return prop;
+}
+
+/**
+ * 
+ * @param props The properties to check
+ * @param userId The userId trying to copy these properties to a library
+ * Checks that every property can be copied out of the library that originated it by this user
+ */
+function assertSourceLibraryCopyPermission(props, method) {
+  // Skip on the client
+  if (method.isSimulation) return;
+
+  // Get all the library node ids that are sources for these properties
+  const libraryNodeIds = [];
+  props.forEach(prop => {
+    if (prop.libraryNodeId) libraryNodeIds.push(prop.libraryNodeId);
+  });
+  if (!libraryNodeIds.length) return;
+
+  // Get the actual library Ids that each of these source nodes came from
+  const sourceLibIds = new Set();
+  LibraryNodes.find({
+    _id: { $in: libraryNodeIds }
+  }, {
+    fields: { root: 1 }
+  }).forEach(node => {
+    sourceLibIds.add(node.root.id);
+  });
+
+  // Assert copy permission on each of those libraries
+  Libraries.find({
+    _id: { $in: Array.from(sourceLibIds) }
+  }, {
+    fields: {
+      name: 1,
+      owner: 1,
+      readers: 1,
+      writers: 1,
+      public: 1,
+      readersCanCopy: 1,
+    }
+  }).forEach(lib => {
+    try {
+      assertCopyPermission(lib, method.userId);
+    } catch (e) {
+      throw new Meteor.Error('Copy permission denied',
+        `One of the properties you are copying comes from ${lib.name}, which you do not have permission to copy from`);
+    }
+  });
+}
+
+export function cleanProps(props) {
+  return props.map(prop => {
+    let schema = LibraryNodes.simpleSchema(prop);
+    return schema.clean(prop);
+  });
+}
+
+export default copyPropertyToLibrary;

app/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js

@@ -1,57 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { recomputePropertyDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-const damagePropertiesByName = new ValidatedMethod({
-  name: 'CreatureProperties.damagePropertiesByName',
-  validate: new SimpleSchema({
-    creatureId: SimpleSchema.RegEx.Id,
-    variableName: {
-      type: String,
-    },
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({creatureId, variableName, operation, value}) {
-		// Check permissions
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        damageMultipliers: 1,
-        owner: 1,
-        readers: 1,
-        writers: 1,
-      },
-    });
-    assertEditPermission(creature, this.userId);
-    let lastProperty;
-    CreatureProperties.find({
-      'ancestors.id': creatureId,
-      variableName,
-      removed: {$ne: false},
-      inactive: {$ne: true},
-    }).forEach(property => {
-      // Check if property can take damage
-      let schema = CreatureProperties.simpleSchema(property);
-      if (!schema.allowsKey('damage')) return;
-      // Damage the property
-      damagePropertyWork({property, operation, value});
-      lastProperty = property;
-    });
-    if (lastProperty) recomputePropertyDependencies(lastProperty);
-  }
-});
-
-export default damagePropertiesByName;

app/imports/api/creature/creatureProperties/methods/damageProperty.js

@@ -1,80 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { recomputePropertyDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-const damageProperty = new ValidatedMethod({
-  name: 'creatureProperties.damage',
-  validate: new SimpleSchema({
-    _id: SimpleSchema.RegEx.Id,
-    operation: {
-      type: String,
-      allowedValues: ['set', 'increment']
-    },
-    value: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({_id, operation, value}) {
-    // Check permissions
-		let property = CreatureProperties.findOne(_id);
-    if (!property) throw new Meteor.Error(
-      'Damage property failed', 'Property doesn\'t exist'
-    );
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
-		// Check if property can take damage
-		let schema = CreatureProperties.simpleSchema(property);
-		if (!schema.allowsKey('damage')){
-			throw new Meteor.Error(
-				'Damage property failed',
-				`Property of type "${property.type}" can't be damaged`
-			);
-		}
-		let result = damagePropertyWork({property, operation, value});
-    // Dependencies can't be changed through damage, only recompute deps
-    recomputePropertyDependencies(property);
-    return result;
-  },
-});
-
-export function damagePropertyWork({property, operation, value}){
-  if (operation === 'set'){
-    let currentValue = property.value;
-    // Set represents what we want the value to be after damage
-    // So we need the actual damage to get to that value
-    let damage = currentValue - value;
-    // Damage can't exceed total value
-    if (damage > currentValue) damage = currentValue;
-    // Damage must be positive
-    if (damage < 0) damage = 0;
-    CreatureProperties.update(property._id, {
-      $set: {damage}
-    }, {
-      selector: property
-    });
-    return currentValue - damage;
-  } else if (operation === 'increment'){
-    let currentValue = property.value - (property.damage || 0);
-    let currentDamage = property.damage;
-    let increment = value;
-    // Can't increase damage above the remaining value
-    if (increment > currentValue) increment = currentValue;
-    // Can't decrease damage below zero
-    if (-increment > currentDamage) increment = -currentDamage;
-    CreatureProperties.update(property._id, {
-      $inc: {damage: increment}
-    }, {
-      selector: property
-    });
-    return increment;
-  }
-}
-
-export default damageProperty;

app/imports/api/creature/creatureProperties/methods/dealDamage.js

@@ -1,73 +0,0 @@
-import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import Creatures from '/imports/api/creature/creatures/Creatures.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { damagePropertyWork } from '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import { recomputeCreatureByDependencies } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-const dealDamage = new ValidatedMethod({
-  name: 'creatureProperties.dealDamage',
-  validate: new SimpleSchema({
-    creatureId: SimpleSchema.RegEx.Id,
-    damageType: {
-      type: String,
-    },
-    amount: Number,
-  }).validator(),
-  mixins: [RateLimiterMixin],
-  rateLimit: {
-    numRequests: 20,
-    timeInterval: 5000,
-  },
-  run({creatureId, damageType, amount}) {
-    // permissions
-    let creature = Creatures.findOne(creatureId, {
-      fields: {
-        damageMultipliers: 1,
-        owner: 1,
-        readers: 1,
-        writers: 1,
-      },
-    });
-    assertEditPermission(creature, this.userId);
-
-    // Get all the health bars and do damage to them
-    let healthBars = CreatureProperties.find({
-      'ancestors.id': creatureId,
-      type: 'attribute',
-      attributeType:'healthBar',
-      removed: {$ne: true},
-      inactive: {$ne: true},
-    }, {
-      sort: {order: -1},
-    });
-    let multiplier = creature.damageMultipliers[damageType];
-    if (multiplier === undefined) multiplier = 1;
-    let totalDamage = Math.floor(amount * multiplier);
-    let damageLeft = totalDamage;
-    if (damageType === 'healing') damageLeft = -totalDamage;
-    let propertyIds = [];
-    let propertiesDependedAponIds = [];
-    healthBars.forEach(healthBar => {
-      if (damageLeft === 0) return;
-      let damageAdded = damagePropertyWork({
-        property: healthBar,
-        operation: 'increment',
-        value: damageLeft,
-      });
-      damageLeft -= damageAdded;
-      propertyIds.push(healthBar._id);
-      propertiesDependedAponIds.push(...healthBar.dependencies);
-    });
-    recomputeCreatureByDependencies({
-      creature,
-      propertyIds,
-      propertiesDependedAponIds,
-    });
-    return totalDamage;
-  },
-});
-
-export default dealDamage;

app/imports/api/creature/creatureProperties/methods/duplicateProperty.js

@@ -1,21 +1,18 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
 import {
-	setLineageOfDocs,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+  getFilter,
+  renewDocIds
+} from '/imports/api/parenting/parentingFunctions';
+import { rebuildNestedSets } from '/imports/api/parenting/parentingFunctions';
 var snackbar;
-if (Meteor.isClient){
+if (Meteor.isClient) {
   snackbar = require(
-    '/imports/ui/components/snackbars/SnackbarQueue.js'
+    '/imports/client/ui/components/snackbars/SnackbarQueue'
   ).snackbar
 }
 
@@ -26,7 +23,7 @@ const duplicateProperty = new ValidatedMethod({
   validate: new SimpleSchema({
     _id: {
       type: String,
-      regEx: SimpleSchema.RegEx.Id,
+      max: 32,
     }
   }).validator(),
   mixins: [RateLimiterMixin],
@@ -34,69 +31,65 @@ const duplicateProperty = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id}) {
+  run({ _id }) {
     let property = CreatureProperties.findOne(_id);
-    let creature = getRootCreatureAncestor(property);
+    if (!property) throw new Meteor.Error('not-found', 'The source property was not found');
+
+    const creature = getRootCreatureAncestor(property);
 
     assertEditPermission(creature, this.userId);
 
     // Renew the doc ID
-    let randomSrc = DDP.randomStream('duplicateProperty');
-    let propertyId = randomSrc.id();
+    const randomSrc = DDP.randomStream('duplicateProperty');
+    const propertyId = randomSrc.id();
     property._id = propertyId;
 
+    // Change the variableName so it isn't immediately overridden
+    if (property.variableName) {
+      property.variableName += 'Copy'
+    }
+
     // Get all the descendants
-    let nodes = CreatureProperties.find({
-			'ancestors.id': _id,
-			removed: {$ne: true},
-		}, {
+    const nodes = CreatureProperties.find({
+      ...getFilter.descendants(property),
+      removed: { $ne: true },
+    }, {
       limit: DUPLICATE_CHILDREN_LIMIT + 1,
-      sort: {order: 1},
+      sort: { left: 1 },
     }).fetch();
 
     // Alert the user if the limit was hit
-    if (nodes.length > DUPLICATE_CHILDREN_LIMIT){
+    if (nodes.length > DUPLICATE_CHILDREN_LIMIT) {
       nodes.pop();
-      if (Meteor.isClient){
+      if (Meteor.isClient) {
         snackbar({
           text: `Only the first ${DUPLICATE_CHILDREN_LIMIT} children were duplicated`,
         });
       }
     }
 
-    // re-map all the ancestors
-    setLineageOfDocs({
-			docArray: nodes,
-			newAncestry : [
-        ...property.ancestors,
-        {id: propertyId, collection: 'creatureProperties'}
-      ],
-			oldParent : {id: _id, collection: 'creatureProperties'},
-		});
-
     // Give the docs new IDs without breaking internal references
-    renewDocIds({docArray: nodes});
-
-    // Order the root node
-    property.order += 0.5;
-
-    // Insert the properties
-		CreatureProperties.batchInsert([property, ...nodes]);
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: property.ancestors[0].id,
+    const allNodes = [property, ...nodes];
+    renewDocIds({
+      docArray: allNodes,
+      idMap: {
+        [_id]: propertyId,
+        [propertyId]: propertyId,
+      },
     });
 
-    // Inserting the active status of the property needs to be denormalised
-    recomputeInactiveProperties(creature._id);
+    // Order the root node
+    property.left = Number.MAX_SAFE_INTEGER - 1;
+    property.right = Number.MAX_SAFE_INTEGER;
 
-    // Recompute the inventory
-    recomputeInventory(creature._id);
+    // Mark the sheet as needing recompute
+    property.dirty = true;
 
-    // Inserting a creature property invalidates dependencies: full recompute
-    recomputeCreatureByDoc(creature);
+    // Insert the properties
+    CreatureProperties.batchInsert(allNodes);
+
+    // Tree structure changed by inserts, reorder the tree
+    rebuildNestedSets(CreatureProperties, property.root.id);
 
     return propertyId;
   },

app/imports/api/creature/creatureProperties/methods/equipItem.js

@@ -1,20 +1,17 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { organizeDoc } from '/imports/api/parenting/organizeMethods.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS.js';
-import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import { organizeDoc } from '/imports/api/parenting/organizeMethods';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
+import BUILT_IN_TAGS from '/imports/constants/BUILT_IN_TAGS';
+import getParentRefByTag from './getParentByTag';
 
 // Equipping or unequipping an item will also change its parent
 const equipItem = new ValidatedMethod({
   name: 'creatureProperties.equip',
-  validate({_id, equipped}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
+  validate({ _id, equipped }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
     if (equipped !== true && equipped !== false) {
       throw new Meteor.Error('No equipped', 'equipped is required to be true or false');
     }
@@ -24,22 +21,22 @@ const equipItem = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({_id, equipped}) {
+  run({ _id, equipped }) {
     let item = CreatureProperties.findOne(_id);
     if (item.type !== 'item') throw new Meteor.Error('wrong type',
-    'Equip and unequip can only be performed on items');
+      'Equip and unequip can only be performed on items');
     let creature = getRootCreatureAncestor(item);
     assertEditPermission(creature, this.userId);
     CreatureProperties.update(_id, {
-      $set: {equipped},
+      $set: { equipped, dirty: true },
     }, {
-			selector: {type: 'item'},
-		});
+      selector: { type: 'item' },
+    });
     let tag = equipped ? BUILT_IN_TAGS.equipment : BUILT_IN_TAGS.carried;
     let parentRef = getParentRefByTag(creature._id, tag);
-    if (!parentRef) parentRef = {id: creature._id, collection: 'creatures'};
+    if (!parentRef) parentRef = { id: creature._id, collection: 'creatures' };
 
-    organizeDoc.call({
+    organizeDoc.callAsync({
       docRef: {
         id: _id,
         collection: 'creatureProperties',
@@ -48,10 +45,6 @@ const equipItem = new ValidatedMethod({
       order: Number.MAX_SAFE_INTEGER,
       skipRecompute: true,
     });
-
-    recomputeInactiveProperties(creature._id);
-    recomputeInventory(creature._id);
-    recomputeCreatureByDoc(creature);
   },
 });
 

app/imports/api/creature/creatureProperties/methods/flipToggle.js

@@ -0,0 +1,47 @@
+import { ValidatedMethod } from 'meteor/mdg:validated-method';
+import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
+
+const flipToggle = new ValidatedMethod({
+  name: 'creatureProperties.flipToggle',
+  validate({ _id }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
+  },
+  mixins: [RateLimiterMixin],
+  rateLimit: {
+    numRequests: 5,
+    timeInterval: 5000,
+  },
+  run({ _id }) {
+    // Permission
+    let property = CreatureProperties.findOne(_id, {
+      fields: { type: 1, root: 1, enabled: 1, disabled: 1 }
+    });
+    if (property.type !== 'toggle') {
+      throw new Meteor.Error('wrong property',
+        'This method can only be applied to toggles');
+    }
+    if (!property.enabled && !property.disabled) {
+      throw new Meteor.Error('Computed toggle',
+        'Can\'t flip a toggle that is computed')
+    }
+    let rootCreature = getRootCreatureAncestor(property);
+    assertEditPermission(rootCreature, this.userId);
+
+    // Invert the current value, disabled is the canonical store of value
+    const currentValue = !property.disabled;
+    CreatureProperties.update(_id, {
+      $set: {
+        enabled: !currentValue,
+        disabled: currentValue,
+        dirty: true,
+      }
+    }, {
+      selector: { type: 'toggle' },
+    });
+  },
+});
+
+export default flipToggle;

app/imports/api/creature/creatureProperties/methods/getParentByTag.js

@@ -0,0 +1,13 @@
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { getFilter } from '/imports/api/parenting/parentingFunctions';
+
+export default function getParentByTag(creatureId, tag) {
+  return CreatureProperties.findOne({
+    ...getFilter.descendantsOfRoot(creatureId),
+    removed: { $ne: true },
+    inactive: { $ne: true },
+    tags: tag,
+  }, {
+    sort: { left: 1 },
+  });
+}

app/imports/api/creature/creatureProperties/methods/getParentRefByTag.js

@@ -1,13 +0,0 @@
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-
-export default function getParentRefByTag(creatureId, tag){
-  let prop = CreatureProperties.findOne({
-    'ancestors.id': creatureId,
-    removed: {$ne: true},
-    inactive: {$ne: true},
-    tags: tag,
-  }, {
-    sort: {order: 1},
-  });
-  return prop && {id: prop._id, collection: 'creatureProperties'};
-}

app/imports/api/creature/creatureProperties/methods/getSlotFillFilter.js

@@ -0,0 +1,79 @@
+import { getFilter } from '/imports/api/parenting/parentingFunctions';
+
+export default function getSlotFillFilter({ slot, libraryIds }) {
+
+  if (!slot) throw 'Slot is required for getSlotFillFilter';
+  if (!libraryIds) throw 'LibraryIds is required for getSlotFillFilter';
+
+  let filter = {
+    fillSlots: true,
+    removed: { $ne: true },
+    $and: [],
+  };
+  if (libraryIds.length) {
+    Object.assign(
+      filter,
+      getFilter.descendantsOfAllRoots(libraryIds)
+    );
+  }
+  if (slot.slotType) {
+    filter.$and.push({
+      $or: [{
+        type: slot.slotType
+      }, {
+        slotFillerType: slot.slotType,
+      }]
+    });
+  } else if (slot.type === 'class') {
+    const classLevelFilter = {
+      type: 'classLevel',
+    };
+    const slotFillerFilter = {
+      slotFillerType: 'classLevel',
+    };
+
+    // Match variable name or tags
+    if (slot.variableName) {
+      classLevelFilter.variableName = slot.variableName;
+      slotFillerFilter.libraryTags = slot.variableName;
+    }
+
+    // Only search for levels the class needs
+    if (slot.missingLevels && slot.missingLevels.length) {
+      classLevelFilter.level = { $in: slot.missingLevels };
+      slotFillerFilter['cache.node.level'] = { $in: slot.missingLevels };
+    } else {
+      classLevelFilter.level = { $gt: slot.level || 0 };
+      slotFillerFilter['cache.node.level'] = { $gt: slot.level || 0 };
+    }
+
+    filter.$and.push({
+      $or: [classLevelFilter, slotFillerFilter]
+    });
+  }
+  let tagsOr = [];
+  let tagsNin = [];
+  if (slot.slotTags && slot.slotTags.length) {
+    tagsOr.push({ libraryTags: { $all: slot.slotTags } });
+  }
+  if (slot.extraTags && slot.extraTags.length) {
+    slot.extraTags.forEach(extra => {
+      if (!extra.tags || !extra.tags.length) return;
+      if (extra.operation === 'OR') {
+        tagsOr.push({ libraryTags: { $all: extra.tags } });
+      } else if (extra.operation === 'NOT') {
+        tagsNin.push(...extra.tags);
+      }
+    });
+  }
+  if (tagsOr.length) {
+    filter.$or = tagsOr;
+  }
+  if (tagsNin.length) {
+    filter.$and.push({ libraryTags: { $nin: tagsNin } });
+  }
+  if (!filter.$and.length) {
+    delete filter.$and;
+  }
+  return filter;
+}

app/imports/api/creature/creatureProperties/methods/getSlotFillFilter.test.js

@@ -0,0 +1,85 @@
+import { assert } from 'chai';
+import getSlotFillFilter from '/imports/api/creature/creatureProperties/methods/getSlotFillFilter';
+
+describe('Slot fill filter', function () {
+
+  it('Gives error if arguments aren\'t provided', function () {
+    assert.throws(
+      () => getSlotFillFilter(undefined),
+      null, null, 'Passing undefined should give an error'
+    );
+    assert.throws(
+      () => getSlotFillFilter({
+        slot: { slotTags: ['tag1'] },
+      }),
+      null, null, 'Passing no libraryIds should give an error'
+    );
+    assert.throws(
+      () => getSlotFillFilter({
+        libraryIds: ['libraryId1'],
+      }),
+      null, null, 'Passing no slot should give an error'
+    );
+  });
+
+  it('filters using basic slot tags', function () {
+    const filter = getSlotFillFilter({
+      slot: {
+        slotTags: ['tag1', 'tag2']
+      },
+      libraryIds: ['libraryId1', 'libraryId2'],
+    });
+    assert.deepStrictEqual(filter, {
+      $or: [{
+        libraryTags: { $all: ['tag1', 'tag2'] }
+      }],
+      'root.id': { $in: ['libraryId1', 'libraryId2'] },
+      removed: { $ne: true },
+      fillSlots: true,
+    });
+  });
+
+  it('filters using slot type', function () {
+    const filter = getSlotFillFilter({
+      slot: {
+        slotTags: ['tag1', 'tag2'],
+        slotType: 'feature',
+      },
+      libraryIds: ['libraryId1', 'libraryId2']
+    });
+    assert.deepStrictEqual(filter.$and, [{
+      $or: [{
+        type: 'feature'
+      }, {
+        slotFillerType: 'feature',
+      }],
+    }]);
+  });
+
+  it('filters using extra tags', function () {
+    const filter = getSlotFillFilter({
+      slot: {
+        slotTags: ['tag1', 'tag2'],
+        extraTags: [
+          { operation: 'OR', tags: ['tag3', 'tag4'] },
+          { operation: 'NOT', tags: ['tag5', 'tag6'] },
+          { operation: 'NOT', tags: ['tag7', 'tag8'] },
+        ],
+      },
+      libraryIds: ['libraryId1', 'libraryId2'],
+    });
+    assert.deepStrictEqual(filter, {
+      $or: [
+        { libraryTags: { $all: ['tag1', 'tag2'] } },
+        { libraryTags: { $all: ['tag3', 'tag4'] } },
+      ],
+      $and: [
+        { libraryTags: { $nin: ['tag5', 'tag6', 'tag7', 'tag8'] } },
+      ],
+      'root.id': { $in: ['libraryId1', 'libraryId2'] },
+      removed: { $ne: true },
+      fillSlots: true,
+    });
+  });
+
+});

app/imports/api/creature/creatureProperties/methods/index.js

@@ -1,14 +1,13 @@
-import '/imports/api/creature/creatureProperties/methods/adjustQuantity.js';
-import '/imports/api/creature/creatureProperties/methods/damagePropertiesByName.js';
-import '/imports/api/creature/creatureProperties/methods/damageProperty.js';
-import '/imports/api/creature/creatureProperties/methods/dealDamage.js';
-import '/imports/api/creature/creatureProperties/methods/duplicateProperty.js';
-import '/imports/api/creature/creatureProperties/methods/equipItem.js';
-import '/imports/api/creature/creatureProperties/methods/insertProperty.js';
-import '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js';
-import '/imports/api/creature/creatureProperties/methods/pullFromProperty.js';
-import '/imports/api/creature/creatureProperties/methods/pushToProperty.js';
-import '/imports/api/creature/creatureProperties/methods/restoreProperty.js';
-import '/imports/api/creature/creatureProperties/methods/selectAmmoItem.js';
-import '/imports/api/creature/creatureProperties/methods/softRemoveProperty.js';
-import '/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js';
+import '/imports/api/creature/creatureProperties/methods/adjustQuantity';
+import '/imports/api/creature/creatureProperties/methods/copyPropertyToLibrary';
+import '/imports/api/creature/creatureProperties/methods/duplicateProperty';
+import '/imports/api/creature/creatureProperties/methods/equipItem';
+import '/imports/api/creature/creatureProperties/methods/insertProperty';
+import '/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode';
+import '/imports/api/creature/creatureProperties/methods/pullFromProperty';
+import '/imports/api/creature/creatureProperties/methods/pushToProperty';
+import '/imports/api/creature/creatureProperties/methods/restoreProperty';
+import '/imports/api/creature/creatureProperties/methods/selectAmmoItem';
+import '/imports/api/creature/creatureProperties/methods/softRemoveProperty';
+import '/imports/api/creature/creatureProperties/methods/updateCreatureProperty';
+import '/imports/api/creature/creatureProperties/methods/flipToggle';

app/imports/api/creature/creatureProperties/methods/insertProperty.js

@@ -1,21 +1,16 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
 import SimpleSchema from 'simpl-schema';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import { getAncestry } from '/imports/api/parenting/parenting.js';
-import getParentRefByTag from '/imports/api/creature/creatureProperties/methods/getParentRefByTag.js';
-import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import { getHighestOrder } from '/imports/api/parenting/order.js';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import { fetchDocByRef, rebuildNestedSets } from '/imports/api/parenting/parentingFunctions';
+import getParentRefByTag from './getParentByTag';
+import { RefSchema } from '/imports/api/parenting/ChildSchema';
 
 const insertProperty = new ValidatedMethod({
   name: 'creatureProperties.insert',
-	validate: new SimpleSchema({
+  validate: new SimpleSchema({
     creatureProperty: {
       type: Object,
       blackbox: true,
@@ -27,28 +22,24 @@ const insertProperty = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty, parentRef}) {
-    // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
-
-		// Check permission to edit
+  run({ creatureProperty, parentRef }) {
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    const parentDoc = fetchDocByRef(parentRef);
+
+    // Check permission to edit
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+      creatureProperty.parentId = parentDoc._id;
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
-    creatureProperty.parent = parentRef;
-    creatureProperty.ancestors = ancestors;
+    creatureProperty.root = { collection: 'creatures', id: rootCreature._id };
 
-		return insertPropertyWork({
-      property: creatureProperty,
-      creature: rootCreature,
-    });
+    return insertPropertyWork(creatureProperty);
   },
 });
 
@@ -61,7 +52,7 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
     },
     creatureId: {
       type: String,
-      regEx: SimpleSchema.RegEx.Id,
+      max: 32,
     },
     tag: {
       type: String,
@@ -78,77 +69,56 @@ const insertPropertyAsChildOfTag = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({creatureProperty, creatureId, tag, tagDefaultName}) {
+  run({ creatureProperty, creatureId, tag, tagDefaultName }) {
     let parentRef = getParentRefByTag(creatureId, tag);
+    let insertFolderFirst = false;
 
-    if (!parentRef){
+    if (!parentRef) {
       // Use the creature as the parent and mark that we need to insert the folder first later
-      var insertFolderFirst = true;
-      parentRef = {id: creatureId, collection: 'creatures'};
+      insertFolderFirst = true;
+      parentRef = { id: creatureId, collection: 'creatures' };
     }
 
-    // get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
-
     // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    const parentDoc = fetchDocByRef(parentRef);
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
+    const root = { collection: 'creatures', id: rootCreature._id };
+
     // Add the folder first if we need to
-    if (insertFolderFirst){
-      let order = getHighestOrder({
-        collection: CreatureProperties,
-        ancestorId: parentRef.id,
-      }) + 1;
+    if (insertFolderFirst) {
       let id = CreatureProperties.insert({
         type: 'folder',
         name: tagDefaultName || (tag.charAt(0).toUpperCase() + tag.slice(1)),
         tags: [tag],
-        parent: parentRef,
-        ancestors: [parentRef],
-        order,
+        // parentId: undefined,
+        root,
       });
       // Make the folder our new parent
-      let newParentRef = {id, collection: 'creatureProperties'};
-      ancestors = [parentRef, newParentRef];
-      parentRef = newParentRef;
-      creatureProperty.order = order + 1;
+      parentRef = { id, collection: 'creatureProperties' };
     }
 
-    creatureProperty.parent = parentRef;
-    creatureProperty.ancestors = ancestors;
+    creatureProperty.root = root;
+    creatureProperty.parentId = parentRef.id;
 
-		return insertPropertyWork({
-      property: creatureProperty,
-      creature: rootCreature,
-    });
+    return insertPropertyWork(creatureProperty);
   },
 });
 
-export function insertPropertyWork({property, creature}){
+export function insertPropertyWork(property) {
   delete property._id;
+  property.dirty = true;
   let _id = CreatureProperties.insert(property);
   // Tree structure changed by insert, reorder the tree
-  reorderDocs({
-    collection: CreatureProperties,
-    ancestorId: creature._id,
-  });
-  // Inserting the active status of the property needs to be denormalised
-  recomputeInactiveProperties(creature._id);
-
-  // Recompute the inventory if it has changed
-  if (property.type === 'item' || property.type === 'container'){
-    recomputeInventory(creature._id);
-  }
-  // Inserting a creature property invalidates dependencies: full recompute
-  recomputeCreatureByDoc(creature);
+  rebuildNestedSets(CreatureProperties, property.root.id);
   return _id;
 }
 

app/imports/api/creature/creatureProperties/methods/insertPropertyFromLibraryNode.js

@@ -1,203 +1,195 @@
 import SimpleSchema from 'simpl-schema';
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import LibraryNodes from '/imports/api/library/LibraryNodes.js';
-import { RefSchema } from '/imports/api/parenting/ChildSchema.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import LibraryNodes from '/imports/api/library/LibraryNodes';
+import { RefSchema } from '/imports/api/parenting/ChildSchema';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
 import {
-	setLineageOfDocs,
-	getAncestry,
-	renewDocIds
-} from '/imports/api/parenting/parenting.js';
-import { reorderDocs } from '/imports/api/parenting/order.js';
-import { setDocToLastOrder } from '/imports/api/parenting/order.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
-import fetchDocByRef from '/imports/api/parenting/fetchDocByRef.js';
+  renewDocIds,
+  fetchDocByRef,
+  rebuildNestedSets,
+  getFilter
+} from '/imports/api/parenting/parentingFunctions';
+import { union } from 'lodash';
 
 const insertPropertyFromLibraryNode = new ValidatedMethod({
-	name: 'creatureProperties.insertPropertyFromLibraryNode',
-	validate: new SimpleSchema({
-		nodeId: {
-			type: String,
-			regEx: SimpleSchema.RegEx.Id,
-		},
-		parentRef: {
-			type: RefSchema,
-		},
-    order: {
-      type: Number,
-      optional: true,
+  name: 'creatureProperties.insertPropertyFromLibraryNode',
+  validate: new SimpleSchema({
+    nodeIds: {
+      type: Array,
+      max: 20,
     },
-	}).validator(),
+    'nodeIds.$': {
+      type: String,
+      max: 32,
+    },
+    parentRef: {
+      type: RefSchema,
+    },
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({nodeId, parentRef, order}) {
-		// get the new ancestry for the properties
-		let {parentDoc, ancestors} = getAncestry({parentRef});
+  run({ nodeIds, parentRef }) {
+    // get the new ancestry for the properties
+    const parentDoc = fetchDocByRef(parentRef);
 
-		// Check permission to edit
+    // Check permission to edit
     let rootCreature;
-		if (parentRef.collection === 'creatures'){
+    if (parentRef.collection === 'creatures') {
       rootCreature = parentDoc;
-		} else if (parentRef.collection === 'creatureProperties'){
+    } else if (parentRef.collection === 'creatureProperties') {
       rootCreature = getRootCreatureAncestor(parentDoc);
-		} else {
-			throw `${parentRef.collection} is not a valid parent collection`
-		}
+    } else {
+      throw `${parentRef.collection} is not a valid parent collection`
+    }
     assertEditPermission(rootCreature, this.userId);
 
-		// Fetch the library node and its decendents, provided they have not been
-		// removed
-    // TODO: Check permission to read the library this node is in
-		let node = LibraryNodes.findOne({
-			_id: nodeId,
-			removed: {$ne: true},
-		});
-		if (!node) throw `Node not found for nodeId: ${nodeId}`;
-		let oldParent = node.parent;
-		let nodes = LibraryNodes.find({
-			'ancestors.id': nodeId,
-			removed: {$ne: true},
-		}).fetch();
+    const root = { collection: 'creatures', id: rootCreature._id };
+    const parentId = parentRef.id;
 
-    // Convert all references into actual nodes
-    nodes = reifyNodeReferences(nodes);
-
-    // The root node is first in the array of nodes
-    // It must get the first generated ID to prevent flickering
-		nodes = [node, ...nodes];
-
-		// re-map all the ancestors
-		setLineageOfDocs({
-			docArray: nodes,
-			newAncestry: ancestors,
-			oldParent,
-		});
-
-		// Give the docs new IDs without breaking internal references
-		renewDocIds({
-			docArray: nodes,
-			collectionMap: {'libraryNodes': 'creatureProperties'}
-		});
-
-		// Order the root node
-    if (order === undefined){
-      setDocToLastOrder({
-        collection: CreatureProperties,
-        doc: node,
-      });
-    } else {
-      node.order = order;
-    }
-
-		// Insert the creature properties
-    CreatureProperties.batchInsert(nodes);
-
-    // get the root inserted doc
-    let rootId = node._id;
-
-    // Tree structure changed by inserts, reorder the tree
-    reorderDocs({
-      collection: CreatureProperties,
-      ancestorId: rootCreature._id,
+    let node;
+    nodeIds.forEach(nodeId => {
+      node = insertPropertyFromNode(nodeId, root, parentId);
     });
 
-    // The library properties need to denormalise which of them are inactive
-    recomputeInactiveProperties(rootId);
-    // Some of the library properties may be items or containers
-    recomputeInventory(rootCreature._id);
-		// Inserting a creature property invalidates dependencies: full recompute
-    recomputeCreatureByDoc(rootCreature);
-		// Return the docId of the last property, the inserted root property
-		return rootId;
-	},
+    // Tree structure changed by inserts, reorder the tree
+    rebuildNestedSets(CreatureProperties, rootCreature._id);
+
+    // get one of the root inserted docs
+    const lastInsertedId = node?._id;
+    return lastInsertedId;
+  },
 });
 
+function insertPropertyFromNode(nodeId, root, parentId) {
+  // Fetch the library node and its descendants, provided they have not been
+  // removed
+  let node = LibraryNodes.findOne({
+    _id: nodeId,
+    removed: { $ne: true },
+  });
+  if (!node) {
+    if (Meteor.isClient) return {};
+    else {
+      throw new Meteor.Error(
+        'Insert property from library failed',
+        `No library document with id '${nodeId}' was found`
+      );
+    }
+  }
+
+  let nodes = LibraryNodes.find({
+    ...getFilter.descendants(node),
+    removed: { $ne: true },
+  }).fetch();
+
+  // The root node is first in the array of nodes
+  // It must get the first generated ID to prevent flickering
+  nodes = [node, ...nodes];
+
+  // Convert all references into actual nodes
+  nodes = reifyNodeReferences(nodes);
+  // Refetch the root node, it might have been reified
+  node = nodes[0] || node;
+
+  // set libraryNodeIds
+  storeLibraryNodeReferences(nodes);
+
+  // Give the docs new IDs without breaking internal references
+  renewDocIds({
+    docArray: nodes,
+    collectionMap: { 'libraryNodes': 'creatureProperties' }
+  });
+
+  // Mark root node as dirty
+  node.dirty = true;
+
+  // Move the root node to the end of the order
+  node.left = Number.MAX_SAFE_INTEGER;
+
+  // Insert the creature properties
+  CreatureProperties.batchInsert(nodes);
+  return node;
+}
+
+export function storeLibraryNodeReferences(nodes) {
+  nodes.forEach(node => {
+    if (node.libraryNodeId) return;
+    node.libraryNodeId = node._id;
+  });
+}
+
 // Covert node references into actual nodes
 // TODO: check permissions for each library a reference node references
-function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0){
+export function reifyNodeReferences(nodes, visitedRefs = new Set(), depth = 0) {
   depth += 1;
   // New nodes added this function
   let newNodes = [];
 
   // Filter out the reference nodes we replace
   let resultingNodes = nodes.filter(node => {
-
-    // We have already visited this ref and replaced it
-    if (visitedRefs.has(node._id)) return false;
-
-    // Already replaced an ancestor node
-    for (let i; i < node.ancestors.length; i++){
-      if (visitedRefs.has(node.ancestors[i].id)) return false;
-    }
-
     // This isn't a reference node, continue as normal
     if (node.type !== 'reference') return true;
 
     // We have gone too deep, keep the reference node as an error
-    if (depth > 10){
+    if (depth >= 10) {
       if (Meteor.isClient) console.warn('Reference depth limit exceeded');
-      node.cache = {error: 'Reference depth limit exceeded'};
+      node.cache = { error: 'Reference depth limit exceeded' };
       return true;
     }
 
     let referencedNode
     try {
       referencedNode = fetchDocByRef(node.ref);
-      referencedNode.order = node.order;
+      referencedNode.tags = union(node.tags, referencedNode.tags);
       // We are definitely replacing this node, so add it to the list
       visitedRefs.add(node._id);
-    } catch (e){
-      node.cache = {error: e.reason || e.message || e.toString()};
+    } catch (e) {
+      node.cache = { error: e.reason || e.message || e.toString() };
       return true;
     }
 
     // Get all the descendants of the referenced node
-    let descendents = LibraryNodes.find({
-      'ancestors.id': referencedNode._id,
-      removed: {$ne: true},
+    let descendants = LibraryNodes.find({
+      ...getFilter.descendants(referencedNode),
+      removed: { $ne: true },
     }, {
-      sort: {order: 1},
+      sort: { left: 1 },
     }).fetch();
 
     // We are adding the referenced node and its descendants
-    let addedNodes = [referencedNode, ...descendents];
+    let addedNodes = [referencedNode, ...descendants];
 
-    // re-map all the ancestors to parent the new sub-tree into our existing
-    // node tree
-		setLineageOfDocs({
-			docArray: addedNodes,
-			newAncestry: node.ancestors,
-			oldParent: referencedNode.parent,
-		});
-
-    // Remove all the looped references and descendents from the new nodes
-    // We can't rely on the reify recursion to do this, since the IDs are
-    // getting renewed before it is called
-    addedNodes = addedNodes.filter(node => {
-      // Exclude removed referenced
-      if (visitedRefs.has(node._id)) return false;
-
-      // Exclude descendants of removed references
-      for (let i; i < node.ancestors.length; i++){
-        if (visitedRefs.has(node.ancestors[i].id)) return false;
+    // Filter all the looped references
+    addedNodes = addedNodes.filter(addedNode => {
+      // Add all non-reference nodes
+      if (addedNode.type !== 'reference') {
+        return true;
+      }
+      // If this exact reference has already been resolved before, filter it out
+      if (visitedRefs.has(addedNode._id)) {
+        return false;
+      } else {
+        // Otherwise mark it as visited, and keep it
+        visitedRefs.add(addedNode._id);
+        return true;
       }
-      return true;
     });
 
-    // TODO: Force the referencedNode to take the old id of the reference
-    // such that the reference's children can be kept
-    
+    // Before renewing Ids make sure the library node reference is stored
+    storeLibraryNodeReferences(addedNodes);
+
     // Give the new referenced sub-tree new ids
+    // The referenced node must get the id of the ref node so that the
+    // descendants of the ref node keep their ancestry intact
     renewDocIds({
       docArray: addedNodes,
+      idMap: { [referencedNode._id]: node._id },
     });
 
     // Reify the subtree as well with recursion

app/imports/api/creature/creatureProperties/methods/pullFromProperty.js

@@ -1,36 +1,32 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
 
 const pullFromProperty = new ValidatedMethod({
-	name: 'creatureProperties.pull',
-	validate: null,
+  name: 'creatureProperties.pull',
+  validate: null,
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id, path, itemId}){
+  run({ _id, path, itemId }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-		CreatureProperties.update(_id, {
-			$pull: {[path.join('.')]: {_id: itemId}},
-		}, {
-			selector: {type: property.type},
-			getAutoValues: false,
-		});
-
-    // TODO figure out if this method can change deps or not
-    recomputeCreatureByDoc(rootCreature);
-    // recomputePropertyDependencies(property);
-	}
+    CreatureProperties.update(_id, {
+      $pull: { [path.join('.')]: { _id: itemId } },
+      $set: { dirty: true }
+    }, {
+      selector: { type: property.type },
+      getAutoValues: false,
+    });
+  }
 });
 
 export default pullFromProperty;

app/imports/api/creature/creatureProperties/methods/pushToProperty.js

@@ -1,35 +1,49 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
+import { get } from 'lodash';
 
 const pushToProperty = new ValidatedMethod({
-	name: 'creatureProperties.push',
-	validate: null,
+  name: 'creatureProperties.push',
+  validate: null,
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id, path, value}){
+  run({ _id, path, value }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
-    // Do work
-		CreatureProperties.update(_id, {
-			$push: {[path.join('.')]: value},
-		}, {
-			selector: {type: property.type},
-		});
+    let joinedPath = path.join('.');
 
-    // TODO figure out if this method can change deps or not
-    recomputeCreatureByDoc(rootCreature);
-    // recomputePropertyDependencies(property);
-	}
+    // Respect maxCount
+    let schema = CreatureProperties.simpleSchema(property);
+    let maxCount = schema.get(joinedPath, 'maxCount');
+
+    if (Number.isFinite(maxCount)) {
+      let array = get(property, path);
+      let currentCount = array ? array.length : 0;
+      if (currentCount >= maxCount) {
+        throw new Meteor.Error(
+          'Array is full',
+          `Cannot have more than ${maxCount} values`
+        );
+      }
+    }
+
+    // Do work
+    CreatureProperties.update(_id, {
+      $push: { [joinedPath]: value },
+      $set: { dirty: true },
+    }, {
+      selector: { type: property.type },
+    });
+  }
 });
 
 export default pushToProperty;

app/imports/api/creature/creatureProperties/methods/restoreProperty.js

@@ -1,40 +1,30 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { restore } from '/imports/api/parenting/softRemove.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import { restore } from '/imports/api/parenting/softRemove';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
 
 const restoreProperty = new ValidatedMethod({
-	name: 'creatureProperties.restore',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'creatureProperties.restore',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id}){
+  run({ _id }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-    restore({_id, collection: CreatureProperties});
-
-    // Items and containers might be restored
-    recomputeInventory(rootCreature._id);
-    // Parents active status may have changed while it was deleted
-    recomputeInactiveProperties(rootCreature._id);
-    // Changes dependency tree by restoring children
-    recomputeCreatureByDoc(rootCreature);
-	}
+    restore(CreatureProperties, property, { $set: { dirty: true } });
+  }
 });
 
 export default restoreProperty;

app/imports/api/creature/creatureProperties/methods/selectAmmoItem.js

@@ -1,10 +1,9 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
 
 const selectAmmoItem = new ValidatedMethod({
   name: 'creatureProperties.selectAmmoItem',
@@ -18,34 +17,29 @@ const selectAmmoItem = new ValidatedMethod({
     numRequests: 5,
     timeInterval: 5000,
   },
-  run({actionId, itemId, itemConsumedIndex}) {
+  run({ actionId, itemId, itemConsumedIndex }) {
     // Permissions
-		let action = CreatureProperties.findOne(actionId);
+    let action = CreatureProperties.findOne(actionId);
     let rootCreature = getRootCreatureAncestor(action);
-		assertEditPermission(rootCreature, this.userId);
+    assertEditPermission(rootCreature, this.userId);
 
     // Check that this index has a document to edit
     let itemConsumed = action.resources.itemsConsumed[itemConsumedIndex];
-    if (!itemConsumed){
+    if (!itemConsumed) {
       throw new Meteor.Error('Resouce not found',
         'Could not set ammo, because the ammo document was not found');
     }
     let itemToLink = CreatureProperties.findOne(itemId);
-    if (!itemToLink){
+    if (!itemToLink) {
       throw new Meteor.Error('Item not found',
         'Could not set ammo: the item was not found');
     }
     let path = `resources.itemsConsumed.${itemConsumedIndex}.itemId`;
     CreatureProperties.update(actionId, {
-      $set: {[path]: itemId}
+      $set: { [path]: itemId, dirty: true }
     }, {
       selector: action,
     });
-
-    // Changing the linked item does change the dependency tree
-    // TODO: We can predict exactly which deps will be affected instead of
-    //       recomputing the entire creature
-    recomputeCreatureByDoc(rootCreature);
   },
 });
 

app/imports/api/creature/creatureProperties/methods/softRemoveProperty.js

@@ -1,37 +1,30 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
 import SimpleSchema from 'simpl-schema';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import { softRemove } from '/imports/api/parenting/softRemove.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { recomputeCreatureByDoc } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertEditPermission } from '/imports/api/sharing/sharingPermissions';
+import { softRemove } from '/imports/api/parenting/softRemove';
+import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor';
 
 const softRemoveProperty = new ValidatedMethod({
-	name: 'creatureProperties.softRemove',
-	validate: new SimpleSchema({
-		_id: SimpleSchema.RegEx.Id
-	}).validator(),
+  name: 'creatureProperties.softRemove',
+  validate: new SimpleSchema({
+    _id: SimpleSchema.RegEx.Id
+  }).validator(),
   mixins: [RateLimiterMixin],
   rateLimit: {
     numRequests: 5,
     timeInterval: 5000,
   },
-	run({_id}){
+  run({ _id }) {
     // Permissions
-		let property = CreatureProperties.findOne(_id);
+    let property = CreatureProperties.findOne(_id);
     let rootCreature = getRootCreatureAncestor(property);
     assertEditPermission(rootCreature, this.userId);
 
     // Do work
-		softRemove({_id, collection: CreatureProperties});
-
-    // Potentially changes items and containers
-    recomputeInventory(rootCreature._id);
-    // Changes dependency tree by removing children
-    recomputeCreatureByDoc(rootCreature);
-	}
+    softRemove(CreatureProperties, property);
+  }
 });
 
 export default softRemoveProperty;

app/imports/api/creature/creatureProperties/methods/updateCreatureProperty.js

@@ -1,66 +1,46 @@
 import { ValidatedMethod } from 'meteor/mdg:validated-method';
 import { RateLimiterMixin } from 'ddp-rate-limiter-mixin';
-import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties.js';
-import { assertEditPermission } from '/imports/api/sharing/sharingPermissions.js';
-import getRootCreatureAncestor from '/imports/api/creature/creatureProperties/getRootCreatureAncestor.js';
-import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-import recomputeInactiveProperties from '/imports/api/creature/denormalise/recomputeInactiveProperties.js';
-import recomputeInventory from '/imports/api/creature/denormalise/recomputeInventory.js';
+import CreatureProperties from '/imports/api/creature/creatureProperties/CreatureProperties';
+import { assertDocEditPermission } from '/imports/api/sharing/sharingPermissions';
 
 const updateCreatureProperty = new ValidatedMethod({
   name: 'creatureProperties.update',
-  validate({_id, path}){
-		if (!_id) throw new Meteor.Error('No _id', '_id is required');
-		// We cannot change these fields with a simple update
-		switch (path[0]){
-			case 'type':
-      case 'order':
-      case 'parent':
-      case 'ancestors':
-			case 'damage':
-				throw new Meteor.Error('Permission denied',
-				'This property can\'t be updated directly');
-		}
+  validate({ _id, path }) {
+    if (!_id) throw new Meteor.Error('No _id', '_id is required');
+    // We cannot change these fields with a simple update
+    switch (path[0]) {
+      case 'type':
+      case 'root':
+      case 'left':
+      case 'right':
+      case 'parentId':
+        throw new Meteor.Error('Permission denied',
+          'This property can\'t be updated directly');
+    }
   },
   mixins: [RateLimiterMixin],
   rateLimit: {
-    numRequests: 5,
+    numRequests: 12,
     timeInterval: 5000,
   },
-  run({_id, path, value}) {
+  run({ _id, path, value }) {
     // Permission
-    let property = CreatureProperties.findOne(_id, {
-      fields: {type: 1, ancestors: 1}
+    const property = CreatureProperties.findOne(_id, {
+      fields: { type: 1, root: 1 }
     });
-    let rootCreature = getRootCreatureAncestor(property);
-    assertEditPermission(rootCreature, this.userId);
+    assertDocEditPermission(property, this.userId);
 
-    let pathString = path.join('.');
+    const pathString = path.join('.');
     let modifier;
     // unset empty values
-    if (value === null || value === undefined){
-      modifier = {$unset: {[pathString]: 1}};
+    if (value === null || value === undefined) {
+      modifier = { $unset: { [pathString]: 1 }, $set: { dirty: true } };
     } else {
-      modifier = {$set: {[pathString]: value}};
+      modifier = { $set: { [pathString]: value, dirty: true } };
     }
-		CreatureProperties.update(_id, modifier, {
-			selector: {type: property.type},
-		});
-
-    // Some updates might cause other properties to become inactive
-    if ([
-      'applied', 'equipped', 'prepared', 'alwaysPrepared', 'disabled'
-    ].includes(path[0])){
-      recomputeInactiveProperties(rootCreature._id);
-    }
-
-    if (property.type === 'item' || property.type === 'container'){
-      // Potentially changes items and containers
-      recomputeInventory(rootCreature._id);
-    }
-    // Updating a property is likely to change dependencies, do a full recompute
-    // denormalised stats might change, so fetch the creature again
-    recomputeCreatureById(rootCreature._id);
+    CreatureProperties.update(_id, modifier, {
+      selector: { type: property.type },
+    });
   },
 });
 

app/imports/api/creature/creatureProperties/recomputeCreaturesByProperty.js

@@ -1,12 +0,0 @@
-import { recomputeCreatureById } from '/imports/api/creature/computation/methods/recomputeCreature.js';
-
-/**
- * Recomputes all ancestor creatures of this property
- */
-export default function recomputeCreaturesByProperty(property){
-	for (let ref of property.ancestors){
-		if (ref.collection === 'creatures') {
-			recomputeCreatureById.call(ref.id);
-		}
-	}
-}