@nocobase/plugin-ui-schema-storage 0.7.0-alpha.0

package/esm/repository.js

@@ -0,0 +1,858 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Repository } from '@nocobase/database';
+import { uid } from '@nocobase/utils';
+import lodash from 'lodash';
+const nodeKeys = ['properties', 'definitions', 'patternProperties', 'additionalProperties', 'items'];
+function transaction(transactionAbleArgPosition) {
+    return (target, propertyKey, descriptor) => {
+        const originalMethod = descriptor.value;
+        descriptor.value = function (...args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!lodash.isNumber(transactionAbleArgPosition)) {
+                    transactionAbleArgPosition = originalMethod.length - 1;
+                }
+                let transaction = lodash.get(args, [transactionAbleArgPosition, 'transaction']);
+                let handleTransaction = false;
+                if (!transaction) {
+                    transaction = yield this.database.sequelize.transaction();
+                    handleTransaction = true;
+                    lodash.set(args, transactionAbleArgPosition, Object.assign(Object.assign({}, lodash.get(args, transactionAbleArgPosition, {})), { transaction }));
+                }
+                if (handleTransaction) {
+                    try {
+                        const results = yield originalMethod.apply(this, args);
+                        yield transaction.commit();
+                        return results;
+                    }
+                    catch (e) {
+                        yield transaction.rollback();
+                        throw e;
+                    }
+                }
+                else {
+                    return yield originalMethod.apply(this, args);
+                }
+            });
+        };
+        return descriptor;
+    };
+}
+export class UiSchemaRepository extends Repository {
+    tableNameAdapter(tableName) {
+        if (this.database.sequelize.getDialect() === 'postgres') {
+            return `"${tableName}"`;
+        }
+        return tableName;
+    }
+    get uiSchemasTableName() {
+        return this.tableNameAdapter(this.model.tableName);
+    }
+    get uiSchemaTreePathTableName() {
+        const model = this.database.getCollection('uiSchemaTreePath').model;
+        return this.tableNameAdapter(model.tableName);
+    }
+    sqlAdapter(sql) {
+        if (this.database.sequelize.getDialect() === 'mysql') {
+            return lodash.replace(sql, /"/g, '`');
+        }
+        return sql;
+    }
+    static schemaToSingleNodes(schema, carry = [], childOptions = null) {
+        const node = lodash.cloneDeep(lodash.isString(schema)
+            ? {
+                'x-uid': schema,
+            }
+            : schema);
+        if (!lodash.get(node, 'name')) {
+            node.name = uid();
+        }
+        if (!lodash.get(node, 'x-uid')) {
+            node['x-uid'] = uid();
+        }
+        if (childOptions) {
+            node.childOptions = childOptions;
+        }
+        carry.push(node);
+        for (const nodeKey of nodeKeys) {
+            const nodeProperty = lodash.get(node, nodeKey);
+            const childNodeChildOptions = {
+                parentUid: node['x-uid'],
+                parentPath: [node['x-uid'], ...lodash.get(childOptions, 'parentPath', [])],
+                type: nodeKey,
+            };
+            // array items
+            if (nodeKey === 'items' && nodeProperty) {
+                const handleItems = lodash.isArray(nodeProperty) ? nodeProperty : [nodeProperty];
+                for (const [i, item] of handleItems.entries()) {
+                    carry = this.schemaToSingleNodes(item, carry, Object.assign(Object.assign({}, childNodeChildOptions), { sort: i + 1 }));
+                }
+            }
+            else if (lodash.isPlainObject(nodeProperty)) {
+                const subNodeNames = lodash.keys(lodash.get(node, nodeKey));
+                delete node[nodeKey];
+                for (const [i, subNodeName] of subNodeNames.entries()) {
+                    const subSchema = Object.assign({ name: subNodeName }, lodash.get(nodeProperty, subNodeName));
+                    carry = this.schemaToSingleNodes(subSchema, carry, Object.assign(Object.assign({}, childNodeChildOptions), { sort: i + 1 }));
+                }
+            }
+        }
+        return carry;
+    }
+    getProperties(uid, options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const db = this.database;
+            const rawSql = `
+        SELECT "SchemaTable"."x-uid" as "x-uid", "SchemaTable"."name" as "name", "SchemaTable"."schema" as "schema",
+               TreePath.depth as depth,
+               NodeInfo.type as type, NodeInfo.async as async,  ParentPath.ancestor as parent, ParentPath.sort as sort
+        FROM ${this.uiSchemaTreePathTableName} as TreePath
+                 LEFT JOIN ${this.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
+                 LEFT JOIN ${this.uiSchemaTreePathTableName} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
+                 LEFT JOIN ${this.uiSchemaTreePathTableName} as ParentPath ON (ParentPath.descendant = "SchemaTable"."x-uid" AND ParentPath.depth = 1)
+        WHERE TreePath.ancestor = :ancestor  AND (NodeInfo.async  = false or TreePath.depth = 1)`;
+            const nodes = yield db.sequelize.query(this.sqlAdapter(rawSql), {
+                replacements: {
+                    ancestor: uid,
+                },
+                transaction,
+            });
+            if (nodes[0].length == 0) {
+                return {};
+            }
+            const schema = this.nodesToSchema(nodes[0], uid);
+            return lodash.pick(schema, ['type', 'properties']);
+        });
+    }
+    getJsonSchema(uid, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = this.database;
+            const treeTable = this.uiSchemaTreePathTableName;
+            const rawSql = `
+        SELECT "SchemaTable"."x-uid" as "x-uid", "SchemaTable"."name" as name, "SchemaTable"."schema" as "schema" ,
+               TreePath.depth as depth,
+               NodeInfo.type as type, NodeInfo.async as async,  ParentPath.ancestor as parent, ParentPath.sort as sort
+        FROM ${treeTable} as TreePath
+                 LEFT JOIN ${this.uiSchemasTableName} as "SchemaTable" ON "SchemaTable"."x-uid" =  TreePath.descendant
+                 LEFT JOIN ${treeTable} as NodeInfo ON NodeInfo.descendant = "SchemaTable"."x-uid" and NodeInfo.descendant = NodeInfo.ancestor and NodeInfo.depth = 0
+                 LEFT JOIN ${treeTable} as ParentPath ON (ParentPath.descendant = "SchemaTable"."x-uid" AND ParentPath.depth = 1)
+        WHERE TreePath.ancestor = :ancestor  ${(options === null || options === void 0 ? void 0 : options.includeAsyncNode) ? '' : 'AND (NodeInfo.async != true )'}
+    `;
+            const nodes = yield db.sequelize.query(this.sqlAdapter(rawSql), {
+                replacements: {
+                    ancestor: uid,
+                },
+                transaction: options === null || options === void 0 ? void 0 : options.transaction,
+            });
+            if (nodes[0].length == 0) {
+                return {};
+            }
+            const schema = this.nodesToSchema(nodes[0], uid);
+            return schema;
+        });
+    }
+    ignoreSchemaProperties(schemaProperties) {
+        return lodash.omit(schemaProperties, nodeKeys);
+    }
+    nodesToSchema(nodes, rootUid) {
+        const nodeAttributeSanitize = (node) => {
+            const schema = Object.assign(Object.assign(Object.assign({}, this.ignoreSchemaProperties(lodash.isPlainObject(node.schema) ? node.schema : JSON.parse(node.schema))), lodash.pick(node, [...nodeKeys, 'name'])), { ['x-uid']: node['x-uid'], ['x-async']: !!node.async });
+            if (lodash.isNumber(node.sort)) {
+                schema['x-index'] = node.sort;
+            }
+            return schema;
+        };
+        const buildTree = (rootNode) => {
+            const children = nodes.filter((node) => node.parent == rootNode['x-uid']);
+            if (children.length > 0) {
+                const childrenGroupByType = lodash.groupBy(children, 'type');
+                for (const childType of Object.keys(childrenGroupByType)) {
+                    const properties = childrenGroupByType[childType]
+                        .map((child) => buildTree(child))
+                        .sort((a, b) => a['x-index'] - b['x-index']);
+                    rootNode[childType] =
+                        childType == 'items'
+                            ? properties.length == 1
+                                ? properties[0]
+                                : properties
+                            : properties.reduce((carry, item) => {
+                                carry[item.name] = item;
+                                delete item['name'];
+                                return carry;
+                            }, {});
+                }
+            }
+            return nodeAttributeSanitize(rootNode);
+        };
+        return buildTree(nodes.find((node) => node['x-uid'] == rootUid));
+    }
+    clearAncestor(uid, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = this.database;
+            const treeTable = this.uiSchemaTreePathTableName;
+            yield db.sequelize.query(`DELETE
+       FROM ${treeTable}
+       WHERE descendant IN
+             (SELECT descendant FROM (SELECT descendant FROM ${treeTable} WHERE ancestor = :uid) as descendantTable)
+         AND ancestor IN (SELECT ancestor
+                          FROM (SELECT ancestor FROM ${treeTable} WHERE descendant = :uid AND ancestor != descendant) as ancestorTable)
+      `, {
+                type: 'DELETE',
+                replacements: {
+                    uid,
+                },
+                transaction: options.transaction,
+            });
+        });
+    }
+    patch(newSchema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const rootUid = newSchema['x-uid'];
+            const oldTree = yield this.getJsonSchema(rootUid);
+            const traverSchemaTree = (schema, path = []) => __awaiter(this, void 0, void 0, function* () {
+                const node = schema;
+                const oldNode = path.length == 0 ? oldTree : lodash.get(oldTree, path);
+                const oldNodeUid = oldNode['x-uid'];
+                yield this.updateNode(oldNodeUid, node, transaction);
+                const properties = node.properties;
+                if (lodash.isPlainObject(properties)) {
+                    for (const name of Object.keys(properties)) {
+                        yield traverSchemaTree(properties[name], [...path, 'properties', name]);
+                    }
+                }
+            });
+            yield traverSchemaTree(newSchema);
+        });
+    }
+    updateNode(uid, schema, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodeModel = yield this.findOne({
+                filter: {
+                    'x-uid': uid,
+                },
+            });
+            yield nodeModel.update({
+                schema: Object.assign(Object.assign({}, nodeModel.get('schema')), lodash.omit(schema, ['x-async', 'name', 'x-uid', 'properties'])),
+            }, {
+                hooks: false,
+                transaction,
+            });
+        });
+    }
+    childrenCount(uid, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = this.database;
+            const countResult = yield db.sequelize.query(`SELECT COUNT(*) as count FROM ${this.uiSchemaTreePathTableName} where ancestor = :ancestor and depth  = 1`, {
+                replacements: {
+                    ancestor: uid,
+                },
+                type: 'SELECT',
+                transaction,
+            });
+            return parseInt(countResult[0]['count']);
+        });
+    }
+    isLeafNode(uid, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const childrenCount = yield this.childrenCount(uid, transaction);
+            return childrenCount === 0;
+        });
+    }
+    findParentUid(uid, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parent = yield this.database.getRepository('uiSchemaTreePath').findOne({
+                filter: {
+                    descendant: uid,
+                    depth: 1,
+                },
+                transaction,
+            });
+            return parent ? parent.get('ancestor') : null;
+        });
+    }
+    findNodeSchemaWithParent(uid, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const schema = yield this.database.getRepository('uiSchemas').findOne({
+                filter: {
+                    'x-uid': uid,
+                },
+                transaction,
+            });
+            return {
+                parentUid: yield this.findParentUid(uid, transaction),
+                schema,
+            };
+        });
+    }
+    isSingleChild(uid, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = this.database;
+            const parent = yield this.findParentUid(uid, transaction);
+            if (!parent) {
+                return null;
+            }
+            const parentChildrenCount = yield this.childrenCount(parent, transaction);
+            if (parentChildrenCount == 1) {
+                const schema = yield db.getRepository('uiSchemas').findOne({
+                    filter: {
+                        'x-uid': parent,
+                    },
+                    transaction,
+                });
+                return schema;
+            }
+            return null;
+        });
+    }
+    removeEmptyParents(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction, uid, breakRemoveOn } = options;
+            const removeParent = (nodeUid) => __awaiter(this, void 0, void 0, function* () {
+                const parent = yield this.isSingleChild(nodeUid, transaction);
+                if (parent && !this.breakOnMatched(parent, breakRemoveOn)) {
+                    yield removeParent(parent.get('x-uid'));
+                }
+                else {
+                    yield this.remove(nodeUid, { transaction });
+                }
+            });
+            yield removeParent(uid);
+        });
+    }
+    breakOnMatched(schemaInstance, breakRemoveOn) {
+        if (!breakRemoveOn) {
+            return false;
+        }
+        for (const key of Object.keys(breakRemoveOn)) {
+            const instanceValue = schemaInstance.get(key);
+            const breakRemoveOnValue = breakRemoveOn[key];
+            if (instanceValue !== breakRemoveOnValue) {
+                return false;
+            }
+        }
+        return true;
+    }
+    recursivelyRemoveIfNoChildren(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { uid, transaction, breakRemoveOn } = options;
+            const removeLeafNode = (nodeUid) => __awaiter(this, void 0, void 0, function* () {
+                const isLeafNode = yield this.isLeafNode(nodeUid, transaction);
+                if (isLeafNode) {
+                    const { parentUid, schema } = yield this.findNodeSchemaWithParent(nodeUid, transaction);
+                    if (this.breakOnMatched(schema, breakRemoveOn)) {
+                        // break at here
+                        return;
+                    }
+                    else {
+                        // remove current node
+                        yield this.remove(nodeUid, {
+                            transaction,
+                        });
+                        // continue remove
+                        yield removeLeafNode(parentUid);
+                    }
+                }
+            });
+            yield removeLeafNode(uid);
+        });
+    }
+    remove(uid, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let { transaction } = options;
+            if (options === null || options === void 0 ? void 0 : options.removeParentsIfNoChildren) {
+                yield this.removeEmptyParents({ transaction, uid, breakRemoveOn: options.breakRemoveOn });
+                return;
+            }
+            yield this.database.sequelize.query(this.sqlAdapter(`DELETE FROM ${this.uiSchemasTableName} WHERE "x-uid" IN (
+            SELECT descendant FROM ${this.uiSchemaTreePathTableName} WHERE ancestor = :uid
+        )`), {
+                replacements: {
+                    uid,
+                },
+                transaction,
+            });
+            yield this.database.sequelize.query(` DELETE FROM ${this.uiSchemaTreePathTableName}
+            WHERE descendant IN (
+                select descendant FROM
+                    (SELECT descendant
+                     FROM ${this.uiSchemaTreePathTableName}
+                     WHERE ancestor = :uid)as descendantTable) `, {
+                replacements: {
+                    uid,
+                },
+                transaction,
+            });
+        });
+    }
+    insertBeside(targetUid, schema, side, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const targetParent = yield this.findParentUid(targetUid, transaction);
+            const db = this.database;
+            const treeTable = this.uiSchemaTreePathTableName;
+            const typeQuery = yield db.sequelize.query(`SELECT type from ${treeTable} WHERE ancestor = :uid AND depth = 0;`, {
+                type: 'SELECT',
+                replacements: {
+                    uid: targetUid,
+                },
+                transaction,
+            });
+            const nodes = UiSchemaRepository.schemaToSingleNodes(schema);
+            const rootNode = nodes[0];
+            rootNode.childOptions = {
+                parentUid: targetParent,
+                type: typeQuery[0]['type'],
+                position: {
+                    type: side,
+                    target: targetUid,
+                },
+            };
+            const insertedNodes = yield this.insertNodes(nodes, options);
+            return yield this.getJsonSchema(insertedNodes[0].get('x-uid'), {
+                transaction,
+            });
+        });
+    }
+    insertInner(targetUid, schema, position, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const nodes = UiSchemaRepository.schemaToSingleNodes(schema);
+            const rootNode = nodes[0];
+            rootNode.childOptions = {
+                parentUid: targetUid,
+                type: lodash.get(schema, 'x-node-type', 'properties'),
+                position,
+            };
+            const insertedNodes = yield this.insertNodes(nodes, options);
+            return yield this.getJsonSchema(insertedNodes[0].get('x-uid'), {
+                transaction,
+            });
+        });
+    }
+    schemaExists(schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (lodash.isObject(schema) && !schema['x-uid']) {
+                return false;
+            }
+            const { transaction } = options;
+            const result = yield this.database.sequelize.query(this.sqlAdapter(`select "x-uid" from ${this.uiSchemasTableName} where "x-uid" = :uid`), {
+                type: 'SELECT',
+                replacements: {
+                    uid: lodash.isString(schema) ? schema : schema['x-uid'],
+                },
+                transaction,
+            });
+            return result.length > 0;
+        });
+    }
+    insertAdjacent(position, target, schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            if (options.wrap) {
+                // insert wrap schema using insertNewSchema
+                const wrapSchemaNodes = yield this.insertNewSchema(options.wrap, {
+                    transaction,
+                    returnNode: true,
+                });
+                const lastWrapNode = wrapSchemaNodes[wrapSchemaNodes.length - 1];
+                // insert schema into wrap schema
+                yield this.insertAdjacent('afterBegin', lastWrapNode['x-uid'], schema, lodash.omit(options, 'wrap'));
+                schema = wrapSchemaNodes[0]['x-uid'];
+                options.removeParentsIfNoChildren = false;
+            }
+            else {
+                const schemaExists = yield this.schemaExists(schema, { transaction });
+                if (schemaExists) {
+                    schema = lodash.isString(schema) ? schema : schema['x-uid'];
+                }
+                else {
+                    const insertedSchema = yield this.insertNewSchema(schema, {
+                        transaction,
+                        returnNode: true,
+                    });
+                    schema = insertedSchema[0]['x-uid'];
+                }
+            }
+            return yield this[`insert${lodash.upperFirst(position)}`](target, schema, options);
+        });
+    }
+    insertAfterBegin(targetUid, schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.insertInner(targetUid, schema, 'first', options);
+        });
+    }
+    insertBeforeEnd(targetUid, schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.insertInner(targetUid, schema, 'last', options);
+        });
+    }
+    insertBeforeBegin(targetUid, schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.insertBeside(targetUid, schema, 'before', options);
+        });
+    }
+    insertAfterEnd(targetUid, schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.insertBeside(targetUid, schema, 'after', options);
+        });
+    }
+    insertNodes(nodes, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const insertedNodes = [];
+            for (const node of nodes) {
+                insertedNodes.push(yield this.insertSingleNode(node, Object.assign(Object.assign({}, options), { transaction })));
+            }
+            return insertedNodes;
+        });
+    }
+    insert(schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const nodes = UiSchemaRepository.schemaToSingleNodes(schema);
+            const insertedNodes = yield this.insertNodes(nodes, options);
+            return this.getJsonSchema(insertedNodes[0].get('x-uid'), {
+                transaction: options === null || options === void 0 ? void 0 : options.transaction,
+            });
+        });
+    }
+    insertNewSchema(schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const nodes = UiSchemaRepository.schemaToSingleNodes(schema);
+            // insert schema fist
+            yield this.database.sequelize.query(this.sqlAdapter(`INSERT INTO ${this.uiSchemasTableName} ("x-uid", "name", "schema") VALUES ${nodes
+                .map((n) => '(?)')
+                .join(',')};`), {
+                replacements: lodash.cloneDeep(nodes).map((node) => {
+                    const { uid, name } = this.prepareSingleNodeForInsert(node);
+                    return [uid, name, JSON.stringify(node)];
+                }),
+                type: 'insert',
+                transaction,
+            });
+            const treePathData = lodash.cloneDeep(nodes).reduce((carry, item) => {
+                const { uid, childOptions, async } = this.prepareSingleNodeForInsert(item);
+                return [
+                    ...carry,
+                    // self reference
+                    [uid, uid, 0, (childOptions === null || childOptions === void 0 ? void 0 : childOptions.type) || null, async, null],
+                    // parent references
+                    ...lodash.get(childOptions, 'parentPath', []).map((parentUid, index) => {
+                        return [parentUid, uid, index + 1, null, null, childOptions.sort];
+                    }),
+                ];
+            }, []);
+            // insert tree path
+            yield this.database.sequelize.query(this.sqlAdapter(`INSERT INTO ${this.uiSchemaTreePathTableName} (ancestor, descendant, depth, type, async, sort) VALUES ${treePathData.map((item) => '(?)').join(',')}`), {
+                replacements: treePathData,
+                type: 'insert',
+                transaction,
+            });
+            const rootNode = nodes[0];
+            if (rootNode['x-server-hooks']) {
+                const rootModel = yield this.findOne({ filter: { 'x-uid': rootNode['x-uid'] }, transaction });
+                yield this.database.emitAsync(`${this.collection.name}.afterCreateWithAssociations`, rootModel, options);
+            }
+            if (options === null || options === void 0 ? void 0 : options.returnNode) {
+                return nodes;
+            }
+            return this.getJsonSchema(nodes[0]['x-uid'], {
+                transaction,
+            });
+        });
+    }
+    insertSchemaRecord(name, uid, schema, transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const serverHooks = schema['x-server-hooks'] || [];
+            const node = yield this.create({
+                values: {
+                    name,
+                    ['x-uid']: uid,
+                    schema,
+                    serverHooks,
+                },
+                transaction,
+                context: {
+                    disableInsertHook: true,
+                },
+            });
+            return node;
+        });
+    }
+    prepareSingleNodeForInsert(schema) {
+        const uid = schema['x-uid'];
+        const name = schema['name'];
+        const async = lodash.get(schema, 'x-async', false);
+        const childOptions = schema['childOptions'];
+        delete schema['x-uid'];
+        delete schema['x-async'];
+        delete schema['name'];
+        delete schema['childOptions'];
+        return { uid, name, async, childOptions };
+    }
+    insertSingleNode(schema, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { transaction } = options;
+            const db = this.database;
+            const { uid, name, async, childOptions } = this.prepareSingleNodeForInsert(schema);
+            let savedNode;
+            // check node exists or not
+            const existsNode = yield this.findOne({
+                filter: {
+                    'x-uid': uid,
+                },
+                transaction,
+            });
+            const treeTable = this.uiSchemaTreePathTableName;
+            if (existsNode) {
+                savedNode = existsNode;
+            }
+            else {
+                savedNode = yield this.insertSchemaRecord(name, uid, schema, transaction);
+            }
+            if (childOptions) {
+                const oldParentUid = yield this.findParentUid(uid, transaction);
+                const parentUid = childOptions.parentUid;
+                const childrenCount = yield this.childrenCount(uid, transaction);
+                const isTree = childrenCount > 0;
+                // if node is a tree root move tree to new path
+                if (isTree) {
+                    yield this.clearAncestor(uid, { transaction });
+                    // insert new tree path
+                    yield db.sequelize.query(`INSERT INTO ${treeTable} (ancestor, descendant, depth)
+           SELECT supertree.ancestor, subtree.descendant, supertree.depth + subtree.depth + 1
+           FROM ${treeTable} AS supertree
+                    CROSS JOIN ${treeTable} AS subtree
+           WHERE supertree.descendant = :parentUid
+             AND subtree.ancestor = :uid;`, {
+                        type: 'INSERT',
+                        replacements: {
+                            uid,
+                            parentUid,
+                        },
+                        transaction,
+                    });
+                }
+                // update type
+                yield db.sequelize.query(`UPDATE ${treeTable} SET type = :type WHERE depth = 0 AND ancestor = :uid AND descendant = :uid`, {
+                    type: 'update',
+                    transaction,
+                    replacements: {
+                        type: childOptions.type,
+                        uid,
+                    },
+                });
+                if (!isTree) {
+                    if (existsNode) {
+                        // remove old path
+                        yield db.sequelize.query(`DELETE FROM ${treeTable} WHERE descendant = :uid AND ancestor != descendant`, {
+                            type: 'DELETE',
+                            replacements: {
+                                uid,
+                            },
+                            transaction,
+                        });
+                    }
+                    // insert tree path
+                    yield db.sequelize.query(`INSERT INTO ${treeTable} (ancestor, descendant, depth)
+           SELECT t.ancestor, :modelKey, depth + 1 FROM ${treeTable} AS t  WHERE t.descendant = :modelParentKey `, {
+                        type: 'INSERT',
+                        transaction,
+                        replacements: {
+                            modelKey: savedNode.get('x-uid'),
+                            modelParentKey: parentUid,
+                        },
+                    });
+                }
+                if (!existsNode) {
+                    // insert type && async
+                    yield db.sequelize.query(`INSERT INTO ${treeTable}(ancestor, descendant, depth, type, async) VALUES (:modelKey, :modelKey, 0, :type, :async )`, {
+                        type: 'INSERT',
+                        replacements: {
+                            modelKey: savedNode.get('x-uid'),
+                            type: childOptions.type,
+                            async,
+                        },
+                        transaction,
+                    });
+                }
+                const nodePosition = childOptions.position || 'last';
+                let sort;
+                // insert at first
+                if (nodePosition === 'first') {
+                    sort = 1;
+                    let updateSql = `UPDATE ${treeTable} as TreeTable
+                SET sort = TreeTable.sort + 1
+                FROM ${treeTable} as NodeInfo
+                WHERE NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0
+                AND TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor and NodeInfo.type = :type`;
+                    // Compatible with mysql
+                    if (this.database.sequelize.getDialect() === 'mysql') {
+                        updateSql = `UPDATE ${treeTable} as TreeTable
+          JOIN ${treeTable} as NodeInfo ON (NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0)
+          SET TreeTable.sort = TreeTable.sort + 1
+          WHERE TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor and NodeInfo.type = :type`;
+                    }
+                    // move all child last index
+                    yield db.sequelize.query(updateSql, {
+                        replacements: {
+                            ancestor: childOptions.parentUid,
+                            type: childOptions.type,
+                        },
+                        transaction,
+                    });
+                }
+                if (nodePosition === 'last') {
+                    const maxSort = yield db.sequelize.query(`SELECT ${this.database.sequelize.getDialect() === 'postgres' ? 'coalesce' : 'ifnull'}(MAX(TreeTable.sort), 0) as maxsort FROM ${treeTable} as TreeTable
+                                                        LEFT JOIN ${treeTable} as NodeInfo
+                                                                  ON NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0
+           WHERE TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor and NodeInfo.type = :type`, {
+                        type: 'SELECT',
+                        replacements: {
+                            ancestor: childOptions.parentUid,
+                            type: childOptions.type,
+                        },
+                        transaction,
+                    });
+                    sort = parseInt(maxSort[0]['maxsort']) + 1;
+                }
+                if (lodash.isPlainObject(nodePosition)) {
+                    const targetPosition = nodePosition;
+                    const target = targetPosition.target;
+                    const targetSort = yield db.sequelize.query(`SELECT TreeTable.sort  as sort FROM ${treeTable} as TreeTable
+                                 LEFT JOIN ${treeTable} as NodeInfo
+                                           ON NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0   WHERE TreeTable.depth = 1 AND TreeTable.ancestor = :ancestor AND TreeTable.descendant = :descendant and NodeInfo.type = :type`, {
+                        type: 'SELECT',
+                        replacements: {
+                            ancestor: childOptions.parentUid,
+                            descendant: target,
+                            type: childOptions.type,
+                        },
+                        transaction,
+                    });
+                    sort = targetSort[0].sort;
+                    if (targetPosition.type == 'after') {
+                        sort += 1;
+                    }
+                    let updateSql = `UPDATE ${treeTable} as TreeTable
+                         SET sort = TreeTable.sort + 1
+                             FROM ${treeTable} as NodeInfo
+                         WHERE NodeInfo.descendant = TreeTable.descendant
+                           and NodeInfo.depth = 0
+                           AND TreeTable.depth = 1
+                           AND TreeTable.ancestor = :ancestor
+                           and TreeTable.sort >= :sort
+                           and NodeInfo.type = :type`;
+                    if (this.database.sequelize.getDialect() === 'mysql') {
+                        updateSql = `UPDATE  ${treeTable} as TreeTable
+JOIN ${treeTable} as NodeInfo ON (NodeInfo.descendant = TreeTable.descendant and NodeInfo.depth = 0)
+SET TreeTable.sort = TreeTable.sort + 1
+WHERE TreeTable.depth = 1 AND  TreeTable.ancestor = :ancestor and TreeTable.sort >= :sort and NodeInfo.type = :type`;
+                    }
+                    yield db.sequelize.query(updateSql, {
+                        replacements: {
+                            ancestor: childOptions.parentUid,
+                            sort,
+                            type: childOptions.type,
+                        },
+                        transaction,
+                    });
+                }
+                // update order
+                const updateSql = `UPDATE ${treeTable} SET sort = :sort WHERE depth = 1 AND ancestor = :ancestor AND descendant = :descendant`;
+                yield db.sequelize.query(updateSql, {
+                    type: 'UPDATE',
+                    replacements: {
+                        ancestor: childOptions.parentUid,
+                        sort,
+                        descendant: uid,
+                    },
+                    transaction,
+                });
+                // move node to new parent
+                if (oldParentUid !== null && oldParentUid !== parentUid) {
+                    yield this.database.emitAsync('uiSchemaMove', savedNode, {
+                        transaction,
+                        oldParentUid,
+                        parentUid,
+                    });
+                    if (options.removeParentsIfNoChildren) {
+                        yield this.recursivelyRemoveIfNoChildren({
+                            transaction,
+                            uid: oldParentUid,
+                            breakRemoveOn: options.breakRemoveOn,
+                        });
+                    }
+                }
+            }
+            else {
+                // insert root node path
+                yield db.sequelize.query(`INSERT INTO ${treeTable}(ancestor, descendant, depth, async) VALUES (:modelKey, :modelKey, 0, :async )`, {
+                    type: 'INSERT',
+                    replacements: {
+                        modelKey: savedNode.get('x-uid'),
+                        async,
+                    },
+                    transaction,
+                });
+            }
+            return savedNode;
+        });
+    }
+}
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "clearAncestor", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "patch", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "remove", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertBeside", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertInner", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertAdjacent", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertAfterBegin", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertBeforeEnd", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertBeforeBegin", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertAfterEnd", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertNodes", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insert", null);
+__decorate([
+    transaction()
+], UiSchemaRepository.prototype, "insertNewSchema", null);
+export default UiSchemaRepository;
+//# sourceMappingURL=repository.js.map