Node library

import {connect} from '/lib/xp/node';

const connection = connect({
    repoId: 'my-repo',
    branch: 'master'
});

import {multiRepoConnect} from '/lib/xp/node';

const searchConnection = multiRepoConnect({
    sources: [
        {
            repoId: 'my-repo',
            branch: 'myBranch',
            principals: ["role:system.admin"]
        },
        {
            repoId: 'my-other-repo',
            branch: 'master',
            principals: ["role:system.admin"]
        }
    ]
});

const result = multiRepoConnection.query({
    start: 0,
    count: 2,
    query: "startTime > instant('2016-10-11T14:38:54.454Z')",
    filters: {
        boolean: {
            must: {
                exists: {
                    field: "modifiedTime"
                }
            },
            mustNot: {
                hasValue: {
                    field: "myField",
                    values: [
                        "cheese",
                        "fish",
                        "onion"
                    ]
                }
            }
        },
        notExists: {
            field: "unwantedField"
        },
        ids: {
            values: ["id1", "id2"]
        }
    }
});

const expected = {
    total: 12902,
    count: 2,
    hits: [
        {
            id: "b186d24f-ac38-42ca-a6db-1c1bda6c6c26",
            score: 1.2300000190734863,
            repoId: "my-repo",
            branch: "master"
        },
        {
            id: "350ba4a6-589c-498b-8af0-f183850e1120",
            score: 1.399999976158142,
            repoId: "com.enonic.cms.default",
            branch: "draft"
        }
    ]
}

const result1 = repo.commit({keys: 'nodeId'});

const expected = {
    id: "aa1f76bf-4bb9-41be-b166-03561c1555b2",
    message: "",
    committer: "user:system:anonymous",
    timestamp: "2019-01-24T15:16:36.260799Z"
}

const result2 = repo.commit({
    keys: ['nodeId', 'nodeId2'],
    message: 'Commit message'
});

const expected = {
    id: "aa1f76bf-4bb9-41be-b166-03561c1555b2",
    message: "Commit message",
    committer: "user:system:anonymous",
    timestamp: "2019-01-24T15:19:30.818029Z"
}

const result1 = repo.create({
    _name: 'nerd',
    displayName: 'Carpenter and IT expert',
    likes: 'Plywood',
    numberOfUselessGadgets: 123
});

const expected = {
  _id: "2f0d5c09-39fe-4746-9754-74491d75a185",
  _name: "nerd",
  _path: "/nerd",
  _childOrder: "_ts DESC",
  _indexConfig: {
    default: {
      decideByType: true,
      enabled: true,
      nGram: false,
      fulltext: false,
      includeInAllText: false,
      path: false,
      indexValueProcessors: [],
      languages: []
    },
    configs: []
  },
  _permissions: [
    {
      principal: "role:system.admin",
      allow: [
        "READ",
        "CREATE",
        "MODIFY",
        "DELETE",
        "PUBLISH",
        "READ_PERMISSIONS",
        "WRITE_PERMISSIONS"
      ],
      deny: []
    },
    {
      principal: "role:system.everyone",
      allow: [
        "READ"
      ],
      deny: []
    }
  ],
  _state: "DEFAULT",
  _nodeType: "default",
  _versionKey: "aa95ae7e-b975-4879-a19c-cce3b1fc3742",
  _ts: "2021-05-15T08:46:37.227Z",
  displayName: "Carpenter and IT expert",
  likes: "Plywood",
  numberOfUselessGadgets: 123
}

repo.create({
    _name: "fruits",
    displayName: "Fruit basket",
    description: "language indices usage example",
    english_set: {
      fruit_a: "Apple",
      fruit_set: {
            fruit_b: "Lemon",
            fruit_c: "Orange"
        }
    },
    norwegian_set: {
        fruit_a: "Eple",
        fruit_set: {
            fruit_b: "Sitron",
            fruit_c: "Oransje"
        }
    },
    _indexConfig: {
        default: {
            enabled: true,
            decideByType: true,
            nGram: false,
            fulltext: false,
            includeInAllText: false,
            path: false,
            languages: ['en']
        }, configs: [{
            path: "norwegian_set.**",
            config: {
                enabled: true,
                decideByType: false,
                nGram: true,
                fulltext: true,
                includeInAllText: true,
                path: false,
                languages: ['no']
            }
        }]
    }
});

const result = repo.delete('nodeId', '/node2-path', 'missingNodeId');

[
    "7b175b63-b012-4f20-b31d-b8f78420d7f1",
    "69f225a1-e775-4845-89f0-29b808a9a659"
]

const result = repo.diff({
    key: '/my-name',
    target: 'draft',
    includeChildren: true
});

{
    diff: [
        {
            id: "c8121875-a9b7-42e4-acf2-75cb52687ddb", (1)
            status: "NEWER"
        }
    ]
}

const result = repo.duplicate({
    nodeId: 'nodeId',
    name: 'duplicated-node',
    includeChildren: false,
    dataProcessor: (originalData) => {
        originalData.data.extraProp = 'extraPropValue';
        return originalData;
    },
    parent: '/',
    refresh: 'SEARCH'
});

// Checking if a node exists by path
const result = repo.exists('/path/to/mynode');

if (result) {
    log.info('Node exists');
} else {
    log.info('Node does not exist');
}

// Checking if a node exists by id
const result = repo.exists('77963d9e-b3c8-4a53-85a9-20c375a92742');

if (result) {
    log.info('Node exists');
} else {
    log.info('Node does not exist');
}

const result = repo.findChildren({
    parentKey: "/my-name"
});

const expected = {
    total: 2,
    count: 10,
    hits: [
        {
            id: "c8121875-a9b7-42e4-acf2-75cb52687ddb"
        },
        {
            id: "636a616b-c8e4-480c-afa9-be88a737cf52"
        }
    ]
}

const firstPage = repo.getVersions({
    key: '/my-name',
    count: 2
});

if (firstPage.cursor) {
    const nextPage = repo.getVersions({
        key: '/my-name',
        count: 2,
        cursor: firstPage.cursor
    });
}

const expected = {
    total: 40,
    count: 2,
    cursor: "eyJ0cyI6MTAwMDAwMCwiaWQiOiJub2RlVmVyc2lvbk9sZCJ9",
    hits: [
        {
            versionId: "72dcd8c1-9d70-444d-ad7a-508d8c1865a0",
            nodeId: "ddd1c933-0725-45e8-9a54-a3dd87193f60",
            nodePath: "/my-name",
            timestamp: "2019-05-13T15:56:17.018Z"
        },
        {
            versionId: "04c6b8d7-3c56-458f-80c9-c6ee551fc21d",
            nodeId: "ddd1c933-0725-45e8-9a54-a3dd87193f60",
            nodePath: "/my-name",
            timestamp: "2019-05-13T15:56:16.995Z"
        }
    ]
}

const node = repo.get('nodeId');

const nodes = repo.get('nodeId_1', 'nodeId_2');

const nodes = repo.get(['nodeId_1', 'nodeId_2']);

const nodes = repo.get([{
    key: 'nodeId',
    versionId: 'versionKey'
}, {
    key: '/my-name'
}, 'nodeId']);

const version = repo.getActiveVersion({
    key: '/my-name'
});

const expected = {
    versionId: "72dcd8c1-9d70-444d-ad7a-508d8c1865a0",
    nodeId: "ddd1c933-0725-45e8-9a54-a3dd87193f60",
    nodePath: "/my-name",
    timestamp: "2019-05-13T15:56:17.018Z"
}

const binaryStream = repo.getBinary({
    key: "/myNode",
    binaryReference: "myBinaryReference"
});

const commit = repo.getCommit({
    id: "aa1f76bf-4bb9-41be-b166-03561c1555b2"
});

const expected = {
    id: "aa1f76bf-4bb9-41be-b166-03561c1555b2",
    message: "",
    committer: "user:system:anonymous",
    timestamp: "2019-01-24T15:16:36.260799Z"
}

const result = repo.update({
    key: key,
    editor: (node) => {
        node.someData.cars.push('peugeot');
        return node;
    }
});

const patchedNode = repo.patch({
    key: '/my-node',
    editor: (node) => {
        node.displayName = 'New Display Name';
        node.newField = 'New Value';
        return node;
    }
});

const patchedNode = repo.patch({
    key: '/my-node',
    branches: ['master', 'draft', 'other'],
    editor: (node) => {
        node._childOrder = 'field DESC';
        return node;
    }
});

var ioLib = require('/lib/xp/io');

var stream = ioLib.newStream('Hello World');

const patchedNode = repo.patch({
    key: '/my-node',
    editor: (node) => {
        node.attachmentField = {
            data: stream
        };
        return node;
    }
});

const moved = repo.move({
    source: '/my-name',
    target: 'new-name'
});

const moved = repo.move({
    source: '/my-name',
    target: '/new-parent/'
});

const moved = repo.move({
    source: '/my-name',
    target: '/content/my-site/folder/new-name'
});

const result = repo.push({
    keys: ['a'],
    target: 'otherBranch',
    resolve: false
});

const expected = {
    success: [
        "a"
    ],
    failed: []
}

const result = repo.push({
    keys: ['a'],
    target: 'otherBranch',
    resolve: true,
    includeChildren: true
});

const expected = {
    success: [
        "a",
        "b",
        "c"
    ],
    failed: [
        {
            id: "d",
            reason: "ACCESS_DENIED"
        }
    ]
}

const result = repo.push({
    keys: ['/a'],
    target: 'otherBranch',
    resolve: true,
    includeChildren: true,
    exclude: ['/a/b', '/a/c']
});

const expected = {
    success: [
        "a",
        "d"
    ],
    failed: []
}

const result = repo.query({
    query: "fulltext('_name', '_name')"
});

const expected = {
    total: 4,
    count: 4,
    hits: [
        {
            id: "5be12847-cbad-4e61-a36c-e94ffb597afb",
            score: 0.7071067690849304
        },
        {
            id: "3928476f-915d-4a6a-97cc-f1c8a905f71a",
            score: 0.625
        },
        {
            id: "a2e38aab-6efb-4f20-862c-e23ef24b3fc3",
            score: 0.5
        },
        {
            id: "3a842eff-ef49-4781-8c1a-dcfcf515db51",
            score: 0.5
        }
    ],
    aggregations: {}
}

const result = repo.query({
    start: 0,
    count: 2,
    query: "startTime > instant('2016-10-11T14:38:54.454Z')",
    filters: {
        boolean: {
            must: [
                {
                    exists: {
                        field: "modifiedTime"
                    }
                },
                {
                    exists: {
                        field: "other"
                    }
                }
            ],
            mustNot: {
                hasValue: {
                    field: "myField",
                    values: [
                        "cheese",
                        "fish",
                        "onion"
                    ]
                }
            }
        },
        notExists: {
            field: "unwantedField"
        },
        ids: {
            values: ["id1", "id2"]
        }
    },
    sort: "duration DESC",
    aggregations: {
        urls: {
            terms: {
                field: "url",
                order: "_count desc",
                size: 2
            },
            aggregations: {
                duration: {
                    histogram: {
                        field: "duration",
                        interval: 100,
                        minDocCount: 1,
                        extendedBoundMin: 0,
                        extendedBoundMax: 10000,
                        order: "_key desc"
                    }
                },
                durationStats: {
                    stats: {
                        field: "duration"
                    }
                }
            }
        }
    }
});

const expected = {
    total: 12902,
    count: 2,
    hits: [
        {
            id: "b186d24f-ac38-42ca-a6db-1c1bda6c6c26",
            score: 1.2300000190734863
        },
        {
            id: "350ba4a6-589c-498b-8af0-f183850e1120",
            score: 1.399999976158142
        }
    ],
    aggregations: {
        urls: {
            buckets: [
                {
                    key: "/site/draft/superhero/search",
                    docCount: 6762,
                    duration: {
                        buckets: [
                            {
                                key: "1600",
                                docCount: 2
                            },
                            {
                                key: "1400",
                                docCount: 1
                            },
                            {
                                key: "1300",
                                docCount: 5
                            }
                        ]
                    }
                },
                {
                    key: "/site/draft/superhero",
                    docCount: 1245,
                    duration: {
                        buckets: [
                            {
                                key: "1600",
                                docCount: 2
                            },
                            {
                                key: "1400",
                                docCount: 1
                            },
                            {
                                key: "1300",
                                docCount: 5
                            }
                        ]
                    }
                }
            ]
        }
    }
}

const result = repo.query({
    query: {
        stemmed: {
            field: "description",
            value: "running",
            language: "en"
        }
    }
});

const expected = {
    total: 1,
    count: 1,
    hits: [
        {
            id: "2f0d5c09-39fe-4746-9756-74491d75a185",
            score: 0.5
        }
    ],
    aggregations: {}
}

repo.refresh();

repo.refresh('SEARCH');

const result = repo.sort({
    key: '/name-list',
    childOrder: 'name DESC'
});

repo.applyPermissions({
    key: '/my-node',
    permissions: [
        {
            principal: 'role:system.everyone',
            allow: ['READ']
        },
        {
            principal: 'user:system:my-user',
            allow: ['READ', 'CREATE', 'MODIFY', 'DELETE']
        }
    ]
});

repo.applyPermissions({
    key: '/my-node',
    addPermissions: [
        {
            principal: 'role:system.everyone',
            allow: ['CREATE', 'MODIFY']  // 'READ' permission is already set and will be kept.
        },
        {
            principal: 'user:system:my-new-user',
            allow: ['READ', 'CREATE', 'MODIFY', 'DELETE'] // New user will have all permissions.
        }
    ]
});

repo.applyPermissions({
    key: '/my-node',
    removePermissions: [
        {
            principal: 'role:system.everyone',
            allow: ['CREATE', 'MODIFY']  // 'READ' permission will be kept.
        },
        {
            principal: 'user:system:my-user',
            allow: ['DELETE'] // 'DELETE' permission will be removed. All other permissions will be kept.
        },
        {
            principal: 'user:system:my-new-user' // All permissions for this principal will be removed.
        }
    ]
});

repo.applyPermissions({
    key: '/my-node',
    permissions: [
        {
            principal: 'role:system.everyone',
            allow: ['READ']
        }
    ],
    scope: 'TREE'
});

repo.applyPermissions({
    key: '/my-node',
    permissions: [
        {
            principal: 'role:system.everyone',
            allow: ['READ']
        }
    ],
    scope: 'SUBTREE'
});

repo.applyPermissions({
    key: '/my-node',
    permissions: [
        {
            principal: 'role:system.everyone',
            allow: ['READ']
        }
    ],
    scope: 'TREE',
    branches: ['branch1', 'branch2']
});