@extrahorizon/exh-cli 1.5.0

package/build/commands/data/schemas/util/schemaverify.js

@@ -0,0 +1,202 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SchemaVerify_instances, _SchemaVerify_verifyMetaSchema, _SchemaVerify_verifyTransitionNames, _SchemaVerify_verifyProperties, _SchemaVerify_verifyStatuses, _SchemaVerify_verifyInputConditions, _SchemaVerify_verifyConditionTypes;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaVerify = exports.TestId = void 0;
+var TestId;
+(function (TestId) {
+    TestId[TestId["META_SCHEMA"] = 1] = "META_SCHEMA";
+    TestId[TestId["PROPERTY_VERIFY"] = 2] = "PROPERTY_VERIFY";
+    TestId[TestId["INPUT_CONDITIONS"] = 3] = "INPUT_CONDITIONS";
+    TestId[TestId["STATUS_CHECK"] = 4] = "STATUS_CHECK";
+    TestId[TestId["CONDITION_TYPES"] = 5] = "CONDITION_TYPES";
+    TestId[TestId["TRANSITION_NAMES"] = 6] = "TRANSITION_NAMES";
+})(TestId = exports.TestId || (exports.TestId = {}));
+function transformAjvErrors(offsetPath, errors) {
+    const result = {};
+    for (const error of errors) {
+        const path = offsetPath + error.instancePath;
+        if (!result[path]) {
+            result[path] = [];
+        }
+        result[path].push(`${error.message} ${error.params ? JSON.stringify(error.params) : ''}`);
+    }
+    return Object.keys(result).map(r => [r, ...result[r].map((m) => `\t-${m}`)]).flat();
+}
+class SchemaVerify {
+    constructor(ajv, schema, metaSchema) {
+        _SchemaVerify_instances.add(this);
+        this.ajv = ajv;
+        this.schema = schema;
+        this.metaSchema = metaSchema;
+    }
+    *RunChecks() {
+        yield { id: TestId.META_SCHEMA, test: 'Check if the schema is in the correct form', ...__classPrivateFieldGet(this, _SchemaVerify_instances, "m", _SchemaVerify_verifyMetaSchema).call(this) };
+        yield { id: TestId.PROPERTY_VERIFY, test: 'Check if the properties object is valid JSON schema', ...__classPrivateFieldGet(this, _SchemaVerify_instances, "m", _SchemaVerify_verifyProperties).call(this) };
+        yield { id: TestId.INPUT_CONDITIONS, test: 'Check if all input conditions of transitions are valid JSON schema', ...__classPrivateFieldGet(this, _SchemaVerify_instances, "m", _SchemaVerify_verifyInputConditions).call(this) };
+        yield { id: TestId.STATUS_CHECK, test: 'Check if all statuses are accounted for', ...__classPrivateFieldGet(this, _SchemaVerify_instances, "m", _SchemaVerify_verifyStatuses).call(this) };
+        yield { id: TestId.CONDITION_TYPES, test: 'Check if all condition types are used in the correct transitions', ...__classPrivateFieldGet(this, _SchemaVerify_instances, "m", _SchemaVerify_verifyConditionTypes).call(this) };
+        yield { id: TestId.TRANSITION_NAMES, test: 'Check if all transition names are unique', ...__classPrivateFieldGet(this, _SchemaVerify_instances, "m", _SchemaVerify_verifyTransitionNames).call(this) };
+    }
+    validateTransition(transition, name) {
+        const errors = [];
+        const conditions = transition.conditions || [];
+        for (const [index, condition] of Object.entries(conditions)) {
+            if (condition.type === 'input') {
+                condition.configuration.$schema = 'http://json-schema.org/draft-07/schema#';
+                const isValidConfiguration = this.ajv.validateSchema(condition.configuration);
+                if (!isValidConfiguration) {
+                    errors.push(...transformAjvErrors(`/creationTransition/conditions[${index}]/configuration`, this.ajv.errors));
+                }
+                const result = this.validateConditionPropertiesAgainstSchemaProperties(condition.configuration.properties, this.schema.properties, '');
+                result.forEach((error) => errors.push(`Transition - ${name} : property ${error}`));
+            }
+        }
+        return errors;
+    }
+    validateConditionPropertiesAgainstSchemaProperties(conditionProperties, schemaProperties, path) {
+        const invalidPaths = new Set([]);
+        if (typeof conditionProperties !== 'object') {
+            return invalidPaths;
+        }
+        for (const key of Object.keys(conditionProperties)) {
+            const conditionProperty = conditionProperties[key];
+            const schemaProperty = schemaProperties?.[key];
+            if (key === 'type' && typeof conditionProperty === 'string') {
+                if (schemaProperty && conditionProperty !== schemaProperty) {
+                    invalidPaths.add(`'${path}.type' does not match the value found in the schema properties`);
+                }
+                if (!schemaProperty) {
+                    invalidPaths.add(`'${path}' is defined in the condition properties, but not defined in the schema properties`);
+                }
+            }
+            const currentPath = path ? `${path}.${key}` : key;
+            const result = this.validateConditionPropertiesAgainstSchemaProperties(conditionProperty, schemaProperty, currentPath);
+            result.forEach(error => invalidPaths.add(error));
+        }
+        return invalidPaths;
+    }
+}
+exports.SchemaVerify = SchemaVerify;
+_SchemaVerify_instances = new WeakSet(), _SchemaVerify_verifyMetaSchema = function _SchemaVerify_verifyMetaSchema() {
+    const validate = this.ajv.compile(this.metaSchema);
+    if (!validate(this.schema)) {
+        return { ok: false, errors: transformAjvErrors('', validate.errors) };
+    }
+    return { ok: true, errors: [] };
+}, _SchemaVerify_verifyTransitionNames = function _SchemaVerify_verifyTransitionNames() {
+    const transitionNames = new Set();
+    const nonUniqueNames = new Set();
+    for (const transition of (this.schema.transitions || [])) {
+        const { name } = transition;
+        if (transitionNames.has(name)) {
+            nonUniqueNames.add(name);
+        }
+        else {
+            transitionNames.add(name);
+        }
+    }
+    return { ok: nonUniqueNames.size === 0, errors: [...nonUniqueNames].map(name => `Transition name '${name}' is not unique`) };
+}, _SchemaVerify_verifyProperties = function _SchemaVerify_verifyProperties() {
+    if (this.schema.properties) {
+        const tmpSchema = {
+            $schema: 'http://json-schema.org/draft-07/schema#',
+            type: 'object',
+            properties: this.schema.properties,
+        };
+        if (!this.ajv.validateSchema(tmpSchema)) {
+            return { ok: false, errors: transformAjvErrors('', this.ajv.errors) };
+        }
+        const errors = getIdInObjectArrayErrors(this.schema.properties);
+        if (errors.length > 0) {
+            return { ok: false, errors: errors.map(path => `The following id property is not allowed: ${path}`) };
+        }
+    }
+    return { ok: true, errors: [] };
+}, _SchemaVerify_verifyStatuses = function _SchemaVerify_verifyStatuses() {
+    let ok = true;
+    const errors = [];
+    let statusList = new Set();
+    if (this.schema.transitions) {
+        statusList = new Set([
+            ...statusList.entries(),
+            ...this.schema.transitions.map((t) => t.fromStatuses).flat(),
+            ...this.schema.transitions.map((t) => t.toStatus),
+        ]);
+    }
+    if (this.schema.creationTransition) {
+        statusList = new Set([...statusList.values(), this.schema.creationTransition.toStatus]);
+    }
+    Object.keys(this.schema.statuses || []).forEach(status => {
+        if (!statusList.has(status)) {
+            errors.push(`Status '${status}' is defined in the schema statuses but not used in any transition`);
+            ok = false;
+        }
+    });
+    for (const status of statusList) {
+        if (this.schema.statuses[status] === undefined) {
+            errors.push(`Status '${status}' is not defined in the status list`);
+            ok = false;
+        }
+    }
+    return { ok, errors };
+}, _SchemaVerify_verifyInputConditions = function _SchemaVerify_verifyInputConditions() {
+    let ok = true;
+    const errors = [];
+    if (this.schema.creationTransition?.conditions?.length) {
+        const result = this.validateTransition(this.schema.creationTransition, 'creationTransition');
+        errors.push(...result);
+    }
+    if (this.schema.transitions?.length) {
+        for (const transition of this.schema.transitions) {
+            const result = this.validateTransition(transition, `${transition.name}`);
+            errors.push(...result);
+        }
+    }
+    if (errors.length) {
+        ok = false;
+    }
+    return { ok, errors };
+}, _SchemaVerify_verifyConditionTypes = function _SchemaVerify_verifyConditionTypes() {
+    let ok = true;
+    const errors = [];
+    if (this.schema.transitions) {
+        for (const [tIndex, transition] of this.schema.transitions.entries()) {
+            if (transition.type === 'manual' || !transition.conditions) {
+                continue;
+            }
+            for (const [cIndex, condition] of transition.conditions.entries()) {
+                if (['input', 'initiator'].includes(condition.type)) {
+                    ok = false;
+                    errors.push(`/transitions[${tIndex}]/conditions[${cIndex}] type cannot be ${condition.type} in a non-manual transition`);
+                }
+            }
+        }
+    }
+    return { ok, errors };
+};
+function getIdInObjectArrayErrors(properties, path = []) {
+    const pathsWithIdInArray = [];
+    let name;
+    let value;
+    for ([name, value] of Object.entries(properties)) {
+        while (value.type === 'array' && value.items.type === 'array') {
+            value = value.items;
+            name = `${name}.items`;
+        }
+        if (value.type === 'array' && value.items.type === 'object') {
+            if ('id' in value.items.properties) {
+                pathsWithIdInArray.push([...path, `${name}.items.properties`, 'id'].join('.'));
+            }
+            pathsWithIdInArray.push(...getIdInObjectArrayErrors(value.items.properties, [...path, `${name}.items.properties`]));
+        }
+        if (value.type === 'object') {
+            pathsWithIdInArray.push(...getIdInObjectArrayErrors(value.properties, [...path, `${name}.properties`]));
+        }
+    }
+    return pathsWithIdInArray;
+}

package/build/commands/data/schemas/util/syncSchema.d.ts

@@ -0,0 +1,20 @@
+export declare class SyncSchema {
+    #private;
+    private sdk;
+    private dry;
+    private cloudSchema;
+    private localSchema;
+    static createSchemaSync(sdk: any, dry?: boolean): SyncSchema;
+    constructor(sdk: any, dry?: boolean);
+    sync(target: any): Promise<void>;
+}
+export declare type Changes = {
+    toAdd: string[];
+    toRemove: string[];
+    toUpdate: string[];
+};
+export declare function compareSchemaKey(localSchema: any, cloudSchema: any, key: string): {
+    toAdd: any[];
+    toRemove: any[];
+    toUpdate: any[];
+};

package/build/commands/data/schemas/util/syncSchema.js

@@ -0,0 +1,276 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SyncSchema_instances, _SyncSchema_syncRootAttributes, _SyncSchema_syncProperties, _SyncSchema_updateStatuses, _SyncSchema_syncCreationTransition, _SyncSchema_syncTransitions, _SyncSchema_pruneStatuses, _SyncSchema_syncIndexes;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSchemaKey = exports.SyncSchema = void 0;
+const chalk = require("chalk");
+const _ = require("lodash");
+const schemaRepository = require("../../../../repositories/schemas");
+const statusHelpers_1 = require("../sync/statusHelpers");
+class SyncSchema {
+    constructor(sdk, dry) {
+        _SyncSchema_instances.add(this);
+        this.cloudSchema = null;
+        this.localSchema = null;
+        this.sdk = sdk;
+        this.dry = dry;
+    }
+    static createSchemaSync(sdk, dry) {
+        return new SyncSchema(sdk, dry);
+    }
+    async sync(target) {
+        this.localSchema = target;
+        if (!this.localSchema.name) {
+            console.log('No schema name defined, skipping this file');
+            return;
+        }
+        console.log(`Syncing ${this.localSchema.name}`);
+        this.cloudSchema = await schemaRepository.fetchSchemaByName(this.sdk, this.localSchema.name);
+        if (!this.cloudSchema) {
+            if (this.dry) {
+                console.log(`\t-> Will be created: ${chalk.green(this.localSchema.name)}`);
+                return;
+            }
+            this.cloudSchema = await schemaRepository.createSchema(this.sdk, this.localSchema.name, this.localSchema.description);
+        }
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncRootAttributes).call(this);
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncProperties).call(this);
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_updateStatuses).call(this);
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncCreationTransition).call(this);
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncTransitions).call(this);
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_pruneStatuses).call(this);
+        await __classPrivateFieldGet(this, _SyncSchema_instances, "m", _SyncSchema_syncIndexes).call(this);
+    }
+}
+exports.SyncSchema = SyncSchema;
+_SyncSchema_instances = new WeakSet(), _SyncSchema_syncRootAttributes = async function _SyncSchema_syncRootAttributes() {
+    const diff = diffRootAttributes(this.localSchema, this.cloudSchema);
+    if (this.dry) {
+        reportRootAttributesChanges(this.cloudSchema, diff);
+        return;
+    }
+    if (Object.keys(diff).length > 0) {
+        await schemaRepository.updateSchema(this.sdk, this.cloudSchema.id, diff);
+    }
+}, _SyncSchema_syncProperties = async function _SyncSchema_syncProperties() {
+    console.log(JSON.stringify({ local: this.localSchema, cloud: this.cloudSchema }, null, 2));
+    const propertiesDiff = compareSchemaKey(this.localSchema, this.cloudSchema, 'properties');
+    if (this.dry) {
+        reportSchemaChanges(`Schema ${this.cloudSchema.name} - Properties`, propertiesDiff);
+        return;
+    }
+    const { toAdd, toRemove, toUpdate } = propertiesDiff;
+    for (const key of toAdd) {
+        console.log(`properties: adding ${key}`);
+        await schemaRepository.createProperty(this.sdk, this.cloudSchema.id, {
+            name: key,
+            configuration: this.localSchema.properties[key],
+        });
+    }
+    for (const key of toUpdate) {
+        console.log(`properties: updating ${key}`);
+        await schemaRepository.updateProperty(this.sdk, this.cloudSchema.id, key, this.localSchema.properties[key]);
+    }
+    for (const key of toRemove) {
+        console.log(`properties: removing ${key}`);
+        await schemaRepository.deleteProperty(this.sdk, this.cloudSchema.id, key);
+    }
+}, _SyncSchema_updateStatuses = async function _SyncSchema_updateStatuses() {
+    const changes = (0, statusHelpers_1.compareStatuses)(this.localSchema, this.cloudSchema);
+    if (this.dry) {
+        reportSchemaChanges(`Schema ${this.cloudSchema.name} - Statuses`, changes);
+        return;
+    }
+    const { toAdd, toUpdate } = changes;
+    for (const key of toAdd) {
+        console.log(`statuses: adding ${key}`);
+        await schemaRepository.createStatus(this.sdk, this.cloudSchema.id, key, this.localSchema.statuses[key]);
+    }
+    for (const key of toUpdate) {
+        console.log(`statuses: updating ${key}`);
+        const data = (0, statusHelpers_1.calculateStatusUpdateData)(this.localSchema.statuses[key], this.cloudSchema.statuses[key]);
+        await schemaRepository.updateStatus(this.sdk, this.cloudSchema.id, key, data);
+    }
+}, _SyncSchema_syncCreationTransition = async function _SyncSchema_syncCreationTransition() {
+    if (!this.localSchema.creationTransition) {
+        console.log(`Skipping creationTransition: No creationTransition defined in local ${this.localSchema.name} schema`);
+        return;
+    }
+    if (!_.isEqual(this.cloudSchema.creationTransition, this.localSchema.creationTransition)) {
+        if (this.dry) {
+            console.log('Update creation transition');
+            return;
+        }
+        console.log('creation transition: updating');
+        await schemaRepository.updateCreationTransition(this.sdk, this.cloudSchema.id, this.localSchema.creationTransition);
+    }
+}, _SyncSchema_syncTransitions = async function _SyncSchema_syncTransitions() {
+    const transitionsDiff = compareSchemaKey(this.localSchema, this.cloudSchema, 'transitions');
+    if (this.dry) {
+        reportSchemaChanges(`Schema ${this.cloudSchema.name} - Transitions`, transitionsDiff);
+        return;
+    }
+    const { toAdd, toRemove, toUpdate } = transitionsDiff;
+    for (const transition of toAdd) {
+        console.log(`transitions: adding ${transition.name}`);
+        await schemaRepository.createTransition(this.sdk, this.cloudSchema.id, transition);
+    }
+    for (const transition of toUpdate) {
+        console.log(`transitions: updating ${transition.name}`);
+        const currentTransition = findTransitionByName(transition.name, this.cloudSchema.transitions);
+        await schemaRepository.updateTransition(this.sdk, this.cloudSchema.id, currentTransition.id, transition);
+    }
+    for (const transition of toRemove) {
+        console.log(`transitions: removing ${transition.name}`);
+        await schemaRepository.deleteTransition(this.sdk, this.cloudSchema.id, transition.id);
+    }
+}, _SyncSchema_pruneStatuses = async function _SyncSchema_pruneStatuses() {
+    if (this.dry) {
+        return;
+    }
+    const excessStatuses = _.difference(Object.keys(this.cloudSchema.statuses), Object.keys(this.localSchema.statuses));
+    for (const key of excessStatuses) {
+        console.log(`statuses: removing ${key}`);
+        await schemaRepository.deleteStatus(this.sdk, this.cloudSchema.id, key);
+    }
+}, _SyncSchema_syncIndexes = async function _SyncSchema_syncIndexes() {
+    const { newIndexes, removedIndexes } = compareIndexes(this.localSchema, this.cloudSchema);
+    if (this.dry) {
+        reportIndexChanges(this.localSchema, { newIndexes, removedIndexes });
+        return;
+    }
+    for (const idx of removedIndexes) {
+        console.log(`Indexes: remove index ${idx.id}`);
+        await schemaRepository.deleteIndex(this.sdk, this.cloudSchema.id, idx.id);
+    }
+    for (const idx of newIndexes) {
+        console.log('\t-> Creating new index');
+        await schemaRepository.createIndex(this.sdk, this.cloudSchema.id, idx);
+    }
+};
+function deepDiff(object, other) {
+    return _.transform(object, (result, value, key) => {
+        if (!_.isEqual(value, other[key])) {
+            result[key] = _.isObject(value) && _.isObject(other[key]) ? deepDiff(value, other[key]) : value;
+        }
+    });
+}
+function diffRootAttributes(localSchema, cloudSchema) {
+    return deepDiff(_.pick(localSchema, 'description', 'defaultLimit', 'maximumLimit', 'createMode', 'readMode', 'updateMode', 'deleteMode', 'groupSyncMode'), _.pick(cloudSchema, 'description', 'defaultLimit', 'maximumLimit', 'createMode', 'readMode', 'updateMode', 'deleteMode', 'groupSyncMode'));
+}
+function reportRootAttributesChanges(cloudSchema, updatedValues) {
+    const changedKeys = Object.keys(updatedValues);
+    console.group(`Schema ${cloudSchema.name} - Root attributes`);
+    if (changedKeys.length < 1) {
+        console.log('No update required.');
+        return;
+    }
+    changedKeys.forEach(key => {
+        console.log(`${chalk.yellow(key)}:\t ${chalk.red(cloudSchema[key])} => ${chalk.green(updatedValues[key])}`);
+    });
+    console.groupEnd();
+}
+function reportSchemaChanges(group, changes) {
+    const { toAdd, toRemove, toUpdate } = changes;
+    console.group(group);
+    if (!toAdd.length && !toRemove.length && !toUpdate.length) {
+        console.log('No update required');
+        return;
+    }
+    toAdd.forEach(key => console.log(`Will be added: ${chalk.green(getIdentifier(key))}`));
+    toRemove.forEach(key => console.log(`Will be removed: ${chalk.red(getIdentifier(key))}`));
+    toUpdate.forEach(key => console.log(`Will be updated: ${chalk.yellow(getIdentifier(key))}`));
+    console.groupEnd();
+}
+function reportIndexChanges(schema, indexChanges) {
+    const { newIndexes, removedIndexes } = indexChanges;
+    const changes = compareArraysByName(newIndexes, removedIndexes);
+    reportSchemaChanges(`Schema ${schema.name} - Indexes`, {
+        toAdd: changes.toAdd.map(v => v.name),
+        toRemove: changes.toRemove.map(v => v.name),
+        toUpdate: changes.toUpdate.map(v => v.name),
+    });
+}
+function compareSchemaKey(localSchema, cloudSchema, key) {
+    if (!localSchema[key] && !cloudSchema[key]) {
+        return {
+            toAdd: [],
+            toRemove: [],
+            toUpdate: [],
+        };
+    }
+    const isLocalPropertyArray = Array.isArray(localSchema[key]);
+    const isCloudPropertyArray = !localSchema[key] && Array.isArray(cloudSchema[key]);
+    if (isLocalPropertyArray || isCloudPropertyArray) {
+        return compareArraysByName(localSchema[key], cloudSchema[key]);
+    }
+    return compareSchemas(localSchema[key], cloudSchema[key]);
+}
+exports.compareSchemaKey = compareSchemaKey;
+function compareSchemas(localSchema, cloudSchema) {
+    const toAdd = _.difference(Object.keys(localSchema), Object.keys(cloudSchema));
+    const toRemove = _.difference(Object.keys(cloudSchema), Object.keys(localSchema));
+    const existingLocalProperties = _(localSchema).omit(toAdd).value();
+    const existingCloudProperties = _(cloudSchema).omit(toRemove).value();
+    const schemaDiff = deepDiff(existingLocalProperties, existingCloudProperties);
+    const toUpdate = Object.keys(schemaDiff);
+    return {
+        toAdd,
+        toRemove,
+        toUpdate,
+    };
+}
+function compareArraysByName(localSchema, cloudSchema) {
+    const toAdd = _.differenceBy(localSchema, cloudSchema, 'name');
+    const toRemove = _.differenceBy(cloudSchema, localSchema, 'name');
+    const existingLocalProperties = _.differenceBy(localSchema, toAdd, 'name');
+    const existingCloudProperties = _.differenceBy(cloudSchema, toRemove, 'name');
+    const toUpdate = _.differenceWith(existingLocalProperties, existingCloudProperties, (targetSchema, currentSchema) => _.isEqual(_.omit(targetSchema, ['id']), _.omit(currentSchema, ['id'])));
+    return {
+        toAdd,
+        toRemove,
+        toUpdate,
+    };
+}
+function findTransitionByName(name, transitions) {
+    return _.find(transitions, transition => transition.name === name);
+}
+function compareIndexes(localSchema, cloudSchema) {
+    const localIndexes = localSchema?.indexes ?? [];
+    const indexesManagedByUser = cloudSchema.indexes
+        .filter((index) => index.system === false)
+        .map((idx) => ({ idx, marked: false }));
+    const newIndexes = [];
+    for (const localIndex of localIndexes) {
+        let existsInCloud = false;
+        for (const cloudIndex of indexesManagedByUser) {
+            const cloudIndexContents = _.omit(cloudIndex.idx, ['name', 'id', 'system']);
+            const localIndexContents = _.omit({ options: {}, ...localIndex }, ['name']);
+            if (_.isEqual(cloudIndexContents, localIndexContents)) {
+                existsInCloud = true;
+                cloudIndex.marked = true;
+                break;
+            }
+        }
+        if (!existsInCloud) {
+            newIndexes.push(localIndex);
+        }
+    }
+    const removedIndexes = indexesManagedByUser
+        .filter((index) => index.marked === false)
+        .map((index) => index.idx);
+    return { removedIndexes, newIndexes };
+}
+function getIdentifier(value) {
+    if (typeof value !== 'object') {
+        return value;
+    }
+    if (value.id) {
+        return value.id;
+    }
+    return value.name;
+}

package/build/commands/data/schemas/util/tests/listFilesInDir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/commands/data/schemas/util/tests/listFilesInDir.test.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const mockFs = require("mock-fs");
+const listFilesInDir_1 = require("../listFilesInDir");
+describe('listFilesInDir', () => {
+    beforeEach(() => {
+        mockFs({
+            'path/to/fake/dir': {
+                'some-file.txt': 'file content here',
+                'first-json-file.json': 'json file here',
+                'a-directory': {
+                    'some-file.txt': 'file content here',
+                    'second-json-file.json': 'json file here',
+                },
+                'empty-directory': {},
+            },
+        });
+    });
+    afterEach(() => {
+        mockFs.restore();
+    });
+    it('Returns a flat array of only json files', () => {
+        expect((0, listFilesInDir_1.flatListFiles)('path/to/fake/dir', '.json')).toStrictEqual([
+            path.join('path/to/fake/dir/a-directory/second-json-file.json'),
+            path.join('path/to/fake/dir/first-json-file.json'),
+        ]);
+    });
+    it('Returns a flat array of all files', () => {
+        expect((0, listFilesInDir_1.flatListFiles)('path/to/fake/dir')).toStrictEqual([
+            path.join('path/to/fake/dir/a-directory/second-json-file.json'),
+            path.join('path/to/fake/dir/a-directory/some-file.txt'),
+            path.join('path/to/fake/dir/first-json-file.json'),
+            path.join('path/to/fake/dir/some-file.txt'),
+        ]);
+    });
+    it('Returns an empty flat array of jpg files', () => {
+        expect((0, listFilesInDir_1.flatListFiles)('path/to/fake/dir', '.jpg')).toStrictEqual([]);
+    });
+});

package/build/commands/data/schemas/verify.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="yargs" />
+export declare const command = "verify";
+export declare const desc = "Syntactically verify a local schema";
+export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "file" | "dir"> & import("yargs").InferredOptionTypes<{
+    file: {
+        describe: string;
+        type: "string";
+    };
+    dir: {
+        describe: string;
+        type: "string";
+    };
+}>>;
+export declare const handler: ({ file, dir, ignoreVerificationErrors }: {
+    file: any;
+    dir: any;
+    ignoreVerificationErrors: any;
+}) => Promise<void>;

package/build/commands/data/schemas/verify.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const fs = require("fs");
+const path = require("path");
+const ajv_1 = require("ajv");
+const chalk = require("chalk");
+const error_1 = require("../../../helpers/error");
+const util_1 = require("../../../helpers/util");
+const listFilesInDir_1 = require("./util/listFilesInDir");
+const metaschema = require("./util/metaschema.json");
+const schemaverify_1 = require("./util/schemaverify");
+exports.command = 'verify';
+exports.desc = 'Syntactically verify a local schema';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
+    file: {
+        describe: 'schema json file which needs to be verified',
+        type: 'string',
+    },
+    dir: {
+        describe: 'directory containing schemas to be verified',
+        type: 'string',
+    },
+}).check(({ file, dir }) => {
+    if (file && (!fs.existsSync(path.resolve(file)) || !fs.lstatSync(path.resolve(file)).isFile())) {
+        throw new Error('Schema file does not exist, please make sure you provided the correct file path');
+    }
+    if (dir === undefined && file === undefined) {
+        throw new Error('Must either specify --file or --dir');
+    }
+    else if (dir !== undefined && file !== undefined) {
+        throw new Error('Cannot specify both --file and --dir');
+    }
+    return true;
+});
+exports.builder = builder;
+const handler = async ({ file, dir, ignoreVerificationErrors }) => {
+    let files = [];
+    if (dir) {
+        files = await (0, listFilesInDir_1.flatListFiles)(dir, '.json');
+    }
+    else {
+        files = [file];
+    }
+    const checkFile = (schemaPath) => {
+        let schema = {};
+        console.log(chalk.bold('Checking', schemaPath));
+        try {
+            schema = require(path.resolve(schemaPath));
+        }
+        catch (err) {
+            console.log(chalk.red(`Failed to load schema file ${file}. Possibly not a valid JSON file`));
+            console.log(err);
+            return;
+        }
+        const ajv = new ajv_1.default();
+        for (const result of (new schemaverify_1.SchemaVerify(ajv, schema, metaschema)).RunChecks()) {
+            if (result.ok) {
+                console.log(chalk.green(`${result.test}... ✓`));
+            }
+            else {
+                console.log(chalk.red(`${result.test}... x`));
+                for (const error of result.errors) {
+                    if (typeof error === 'object') {
+                        console.log('\t', chalk.red(JSON.stringify(error, null, 4)));
+                    }
+                    else {
+                        console.log('\t', chalk.red(error));
+                    }
+                }
+                if (!ignoreVerificationErrors) {
+                    throw new error_1.CommandError(`Schema ${schemaPath} contains error, please fix`);
+                }
+            }
+        }
+        console.log();
+    };
+    for (const f of files) {
+        checkFile(f);
+    }
+};
+exports.handler = handler;

package/build/commands/data/schemas.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="yargs" />
+export declare const command = "schemas <command>";
+export declare const desc = "Manage data schemas";
+export declare const builder: (yargs: any) => import("yargs").Argv<{}>;
+export declare const handler: () => void;

package/build/commands/data/schemas.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const util_1 = require("../../helpers/util");
+exports.command = 'schemas <command>';
+exports.desc = 'Manage data schemas';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).commandDir('schemas');
+exports.builder = builder;
+const handler = () => { };
+exports.handler = handler;

package/build/commands/data.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="yargs" />
+export declare const command = "data <command>";
+export declare const desc = "Manage data";
+export declare const builder: (yargs: any) => import("yargs").Argv<{}>;
+export declare const handler: () => void;