wikibase-edit/dist/tests/integration/utils/sandbox_entities.js

Edit Wikibase from NodeJS

import config from 'config';
import wbkFactory, {} from 'wikibase-sdk';
import WBEdit, {} from '../../../src/lib/index.js';
import { customFetch } from '../../../src/lib/request/fetch.js';
import { objectValues } from '../../../src/lib/utils.js';
import { randomString } from '../../unit/utils.js';
import { getProperty } from './get_property.js';
const wbk = wbkFactory({ instance: config.instance });
const { getEntityIdFromGuid } = wbk;
const wbEdit = WBEdit(config);
// Working around the circular dependency
let addClaim;
async function lateRequire() {
    ({ addClaim } = await import('./sandbox_snaks.js'));
}
setTimeout(lateRequire, 0);
async function createEntity(data = {}) {
    // @ts-expect-error
    data.labels = data.labels || { en: randomString() };
    const { entity } = await wbEdit.entity.create(data);
    // @ts-expect-error
    console.log(`created ${entity.type}`, entity.id, data.datatype || '');
    return entity;
}
let sandboxItemPromise;
export function getSandboxItem() {
    sandboxItemPromise ??= createEntity();
    return sandboxItemPromise;
}
export async function getRefreshedEntity(id) {
    const url = wbk.getEntities({ ids: id });
    const res = await customFetch(url).then(res => res.json());
    return res.entities[id];
}
let claimPromise;
export function getSandboxClaim(datatype = 'string') {
    claimPromise ??= _getSandboxClaim(datatype);
    return claimPromise;
}
async function _getSandboxClaim(datatype) {
    const [item, propertyId] = await Promise.all([
        getSandboxItem(),
        getSandboxPropertyId(datatype),
    ]);
    const propertyClaims = item.claims[propertyId];
    if (propertyClaims)
        return propertyClaims[0];
    const res = await wbEdit.claim.create({ id: item.id, property: propertyId, value: randomString() });
    return res.claim;
}
export async function getRefreshedClaim(guid) {
    const id = getEntityIdFromGuid(guid);
    const entity = await getRefreshedEntity(id);
    if ('claims' in entity) {
        const { claims } = entity;
        for (const propertyClaims of objectValues(claims)) {
            for (const claim of propertyClaims) {
                if (claim.id === guid)
                    return claim;
            }
        }
    }
    throw new Error(`claim not found: ${guid}`);
}
export async function getSandboxItemId() {
    const item = await getSandboxItem();
    return item.id;
}
export async function getSandboxPropertyId(datatype) {
    const property = await getProperty({ datatype });
    return property.id;
}
export async function getSandboxClaimId() {
    const claim = await getSandboxClaim();
    return claim.id;
}
export async function createItem(data = {}) {
    const entity = await createEntity({ ...data, type: 'item' });
    return entity;
}
let someEntityIdPromise;
export async function getSomeItemId() {
    someEntityIdPromise ??= getSandboxItemId();
    return someEntityIdPromise;
}
let someGuid;
export async function getSomeGuid() {
    if (someGuid)
        return someGuid;
    const { guid } = await addClaim({ datatype: 'string', value: randomString() });
    someGuid = guid;
    return guid;
}
export const getReservedItem = createItem;
export const getReservedItemId = () => createItem().then(entity => entity.id);
//# sourceMappingURL=sandbox_entities.js.map