feat: update share endpoint to support more things

Author: KernelDeimos

doc/api/type-tagged.md

@@ -30,9 +30,10 @@ anywhere.
 ## Specification
 
 - The `"$"` key indicates a type (or class) of object
-- Any key beginning with `$` is a **meta-key**
+- Any other key beginning with `$` is a **meta-key**
 - Other keys are not allowed to contain `$`
 - `"$version"` must follow [semver](https://semver.org/)
+- Keys with multiple `"$"` symbols are reserved for future use
 
 ## Alternative Representations
 

packages/backend/src/CoreModule.js

@@ -57,6 +57,9 @@ const install = async ({ services, app, useapi }) => {
     const ArrayUtil = require('./libraries/ArrayUtil');
     services.registerService('util-array', ArrayUtil);
 
+    const LibTypeTagged = require('./libraries/LibTypeTagged');
+    services.registerService('lib-type-tagged', LibTypeTagged);
+    
     // === SERVICES ===
 
     // /!\ IMPORTANT /!\

packages/backend/src/api/APIError.js

@@ -33,6 +33,29 @@ module.exports = class APIError {
             status: 500,
             message: () => `An unknown error occurred`,
         },
+        'format_error': {
+            status: 400,
+            message: ({ message }) => `format error: ${message}`,
+        },
+        'temp_error': {
+            status: 400,
+            message: ({ message }) => `error: ${message}`,
+        },
+        
+        // Things
+        'disallowed_thing': {
+            status: 400,
+            message: ({ thing_type, accepted }) =>
+                `Request contained a ${quot(thing_type)} in a ` +
+                `place where ${quot(thing_type)} isn't accepted` +
+                (
+                    accepted
+                        ? '; ' +
+                            'accepted types are: ' +
+                            accepted.map(v => quot(v)).join(', ')
+                        : ''
+                ) + '.'
+        },
 
         // Unorganized
         'item_with_same_name_exists': {

packages/backend/src/libraries/LibTypeTagged.js

@@ -0,0 +1,88 @@
+const Library = require("../definitions/Library");
+const { whatis } = require("../util/langutil");
+
+class LibTypeTagged extends Library {
+    process (o) {
+        const could_be = whatis(o) === 'object' || Array.isArray(o);
+        if ( ! could_be ) return {
+            $: 'error',
+            code: 'invalid-type',
+            message: 'should be object or array',
+        };
+        
+        const intermediate = this.get_intermediate_(o);
+        
+        if ( ! intermediate.type ) return {
+            $: 'error',
+            code: 'missing-type-param',
+            message: 'type parameter is missing',
+        };
+        
+        return this.intermediate_to_standard_(intermediate);
+    }
+    
+    intermediate_to_standard_ (intermediate) {
+        const out = {};
+        out.$ = intermediate.type;
+        for ( const k in intermediate.meta ) {
+            out['$' + k] = intermediate.meta[k];
+        }
+        for ( const k in intermediate.body ) {
+            out[k] = intermediate.body[k];
+        }
+        return out;
+    }
+    
+    get_intermediate_ (o) {
+        if ( Array.isArray(o) ) {
+            return this.process_array_(o);
+        }
+        
+        if ( o['$'] === '$meta-body' ) {
+            return this.process_structured_(o);
+        }
+        
+        return this.process_standard_(o);
+    }
+    
+    process_array_ (a) {
+        if ( a.length <= 1 || a.length > 3 ) return {
+            $: 'error',
+            code: 'invalid-array-length',
+            message: 'tag-typed arrays should have 1-3 elements',
+        };
+        
+        const [type, body = {}, meta = {}] = a;
+        
+        return { $: '$', type, body, meta };
+    }
+    
+    process_structured_ (o) {
+        if ( ! o.hasOwnProperty('type') ) return {
+            $: 'error',
+            code: 'missing-type-property',
+            message: 'missing "type" property'
+        };
+        
+        return { $: '$', ...o };
+    }
+    
+    process_standard_ (o) {
+        const type = o.$;
+        const meta = {};
+        const body = {};
+        
+        for ( const k in o ) {
+            if ( k === '$' ) continue;
+            if ( k.startsWith('$') ) {
+                meta[k.slice(1)] = o[k];
+            } else {
+                body[k] = o[k];
+            }
+        }
+        
+        return { $: '$', type, meta, body };
+    }
+}
+
+module.exports = LibTypeTagged;