wikibase-cli 16.3.2 → 17.0.0

package/lib/entity_attribute_command.js

@@ -1,10 +1,10 @@
-const entityDataParser = require('./entity_data_parser')
-const entityAttributeParser = require('./entity_attribute_parser')
-const pluralize = require('./pluralize')
-const { grey, red } = require('chalk')
-const _ = require('lodash')
+import { max, padEnd, values } from 'lodash-es'
+import { grey, red } from '#lib/chalk'
+import entityAttributeParser from './entity_attribute_parser.js'
+import { entityDataParser } from './entity_data_parser.js'
+import pluralize from './pluralize.js'
 
-module.exports = (attribute, extraParams) => {
+export async function entityAttributeCommand (attribute, extraParams) {
   let commandName, ids
   if (extraParams) {
     ids = extraParams.ids
@@ -15,13 +15,13 @@ module.exports = (attribute, extraParams) => {
   const props = [ pluarlizedAttribute ]
 
   const parser = async ({ lang, strictLang, output, entities }) => {
-    const entitiesList = _.values(entities)
+    const entitiesList = values(entities)
     const multiEntities = entitiesList.length > 1
-    const maxLength = _.max(entitiesList.map(entity => entity.id.length)) + 1
+    const maxLength = max(entitiesList.map(entity => entity.id.length)) + 1
     entitiesList.forEach(logAttribute(attribute, lang, strictLang, multiEntities, maxLength, output))
   }
 
-  entityDataParser({ commandName, props, parser, ids })
+  await entityDataParser({ commandName, props, parser, ids })
 }
 
 const logAttribute = (attribute, lang, strictLang, multiEntities, maxLength, output) => entity => {
@@ -38,7 +38,7 @@ const logAttribute = (attribute, lang, strictLang, multiEntities, maxLength, out
   }
   // Prefix value with the id if there are multiple entities
   if (multiEntities) {
-    console.log(grey(_.padEnd(entity.id, maxLength)), value || grey('not found'))
+    console.log(grey(padEnd(entity.id, maxLength)), value || grey('not found'))
   } else {
     output(value)
   }

package/lib/entity_attribute_parser.js

@@ -1,8 +1,8 @@
-const _ = require('lodash')
-const pluralize = require('./pluralize')
-const errors_ = require('../lib/errors')
+import { isArray, map, values } from 'lodash-es'
+import errors_ from '#lib/errors'
+import pluralize from './pluralize.js'
 
-module.exports = (entity, attribute, lang, strictLang) => {
+export default (entity, attribute, lang, strictLang) => {
   if (entity.missing != null) return
   const pluarlizedAttribute = pluralize(attribute)
   const { id, type } = entity
@@ -12,9 +12,9 @@ module.exports = (entity, attribute, lang, strictLang) => {
   const attrData = entity[pluarlizedAttribute]
   let valueObj
   if (strictLang != null) valueObj = attrData[strictLang]
-  else valueObj = attrData[lang] || attrData.en || _.values(attrData)[0]
-  if (_.isArray(valueObj)) {
-    return valueObj.map(_.property('value')).join(' | ')
+  else valueObj = attrData[lang] || attrData.en || values(attrData)[0]
+  if (isArray(valueObj)) {
+    return map(valueObj, 'value').join(' | ')
   } else {
     return valueObj && valueObj.value
   }
@@ -23,5 +23,5 @@ module.exports = (entity, attribute, lang, strictLang) => {
 const attributesPerType = {
   item: [ 'labels', 'descriptions', 'aliases' ],
   property: [ 'labels', 'descriptions', 'aliases' ],
-  lexeme: [ 'lemmas' ]
+  lexeme: [ 'lemmas' ],
 }

package/lib/entity_data_parser.js

@@ -1,24 +1,28 @@
-const { get } = require('../lib/request')
-const errors_ = require('../lib/errors')
-const parseId = require('../lib/tolerant_id_parser')()
-const exitOnMissing = require('../lib/exit_on_missing')
+import errors_ from '#lib/errors'
+import { exitOnMissingInstance } from '#lib/exit_on_missing'
+import { outputFactory } from '#lib/output'
+import program from '#lib/program'
+import { get } from '#lib/request'
+import { tolerantIdParserFactory } from '#lib/tolerant_id_parser'
+import wbk from '#lib/wbk'
 
-module.exports = async params => {
+const parseId = tolerantIdParserFactory()
+
+export async function entityDataParser (params) {
   const { commandName, parser, programOptions: options } = params
   let { ids, props } = params
-  const program = require('../lib/program')
 
   // If no commandName has been specified, assume that the options
   // where already parsed and that program.process has already been called
   if (commandName) {
     if (options) options.forEach(option => program.option(...option))
-    program.process(commandName)
+    await program.process(commandName)
   }
 
-  exitOnMissing.instance(program.instance)
+  exitOnMissingInstance(program.instance)
 
-  const { getEntities } = require('../lib/wbk')(program)
-  const output = require('../lib/output')(program)
+  const { getEntities } = wbk(program)
+  const output = outputFactory(program)
 
   const { args, lang, strictLang } = program
 
@@ -32,7 +36,6 @@ module.exports = async params => {
   if (props && props[0] === 'lemmas') props = [ 'info' ]
 
   const url = getEntities({ ids, props })
-
   const body = await get(url)
   const entities = parseEntities(ids, body)
   return parser({ lang, strictLang, program, output, entities })

package/lib/errors.js

@@ -1,4 +1,4 @@
-const { red } = require('chalk')
+import { red } from '#lib/chalk'
 
 const errors_ = {
   new: (message, context) => {
@@ -25,7 +25,7 @@ const errors_ = {
   bundle: (message, context) => {
     const err = errors_.new(message, context)
     errors_.exit(err)
-  }
+  },
 }
 
-module.exports = errors_
+export default errors_

package/lib/execute_function.js

@@ -1,8 +1,8 @@
-const errors_ = require('./errors')
-const validateFunctionArgs = require('./validate_function_args')
+import errors_ from './errors.js'
+import validateFunctionArgs from './validate_function_args.js'
 
-module.exports = (absoluePath, inputArgs) => {
-  let fn = require(absoluePath)
+export async function executeFunction (absoluePath, inputArgs) {
+  let { default: fn } = await import(absoluePath)
   let metadata
 
   if (fn && fn.template) {

package/lib/exit_on_missing.js

@@ -1,4 +1,4 @@
-const { red } = require('chalk')
+import { red } from '#lib/chalk'
 
 const missingInstance = `A Wikibase instance should be specificed.
 
@@ -16,15 +16,14 @@ This can be done in config, ex:
 or with the -e,--sparql-endpoint command option:
   $  wb sparql ./my_query.sparql -e https://query.wikidata.org/sparql`
 
-module.exports = {
-  instance: instance => {
-    if (instance) return
-    console.error(red(missingInstance))
-    process.exit(1)
-  },
-  sparqlEndpoint: sparqlEndpoint => {
-    if (sparqlEndpoint) return
-    console.error(red(missingSparqlEndpoint))
-    process.exit(1)
-  }
+export function exitOnMissingInstance (instance) {
+  if (instance) return
+  console.error(red(missingInstance))
+  process.exit(1)
+}
+
+export function exitOnMissingSparqlEndpoint (sparqlEndpoint) {
+  if (sparqlEndpoint) return
+  console.error(red(missingSparqlEndpoint))
+  process.exit(1)
 }

package/lib/fetch_and_log_entity_revision.js

@@ -1,17 +1,20 @@
-const { get } = require('../lib/request')
-const program = require('./program')
-require('../lib/exit_on_missing').instance(program.instance)
-const { getEntityRevision, simplify } = require('../lib/wbk')(program)
-const { simplify: simplifyOption } = program
-const options = require('../lib/parse_simplify_options')(program)
-const _ = require('lodash')
+import { values } from 'lodash-es'
+import { simplifyEntity } from 'wikibase-sdk'
+import { exitOnMissingInstance } from '#lib/exit_on_missing'
+import optionsFactory from '#lib/parse_simplify_options'
+import { get } from '#lib/request'
+import wbk from '#lib/wbk'
+import program from './program.js'
 
-module.exports = (id, revision) => {
-  const url = getEntityRevision(id, revision)
-  get(url)
-  .then(body => {
-    let entity = _.values(body.entities)[0]
-    if (simplifyOption) entity = simplify.entity(entity, options)
-    console.log(JSON.stringify(entity))
-  })
+exitOnMissingInstance(program.instance)
+
+export async function fetchAndLogEntityRevision (id, revision) {
+  const { getEntityRevision } = wbk(program)
+  const { simplify: simplifyOption } = program
+  const options = optionsFactory(program)
+  const url = getEntityRevision({ id, revision })
+  const body = await get(url)
+  let entity = values(body.entities)[0]
+  if (simplifyOption) entity = simplifyEntity(entity, options)
+  console.log(JSON.stringify(entity))
 }

package/lib/fetch_and_log_guid_data.js

@@ -1,21 +1,29 @@
-const { get } = require('../lib/request')
-const program = require('./program')
-require('../lib/exit_on_missing').instance(program.instance)
-const { getEntities, simplify } = require('../lib/wbk')(program)
-const options = require('../lib/parse_simplify_options')(program)
-const { simplify: simplifyOption } = program
-const output = require('./output')(program)
-const { values } = require('lodash')
+import { values } from 'lodash-es'
+import { getStatementsKey } from 'wikibase-edit/lib/parse_instance.js'
+import { simplifyClaim } from 'wikibase-sdk'
+import { exitOnMissingInstance } from '#lib/exit_on_missing'
+import optionsFactory from '#lib/parse_simplify_options'
+import { get } from '#lib/request'
+import wbk from '#lib/wbk'
+import { outputFactory } from './output.js'
+import program from './program.js'
+
+export async function fetchAndLogGuidData (guid) {
+  exitOnMissingInstance(program.instance)
+  const { getEntities } = wbk(program)
+  const options = optionsFactory(program)
+  const { simplify: simplifyOption } = program
+  const output = outputFactory(program)
 
-module.exports = async guid => {
   const id = guid.split('$')[0].toUpperCase()
   const url = getEntities({ ids: id, props: 'claims' })
 
   const { entities } = await get(url)
   const entity = entities[id]
-  let claim = findClaim(entity.claims, guid)
+  const statementsKey = getStatementsKey(program.instance)
+  let claim = findClaim(entity[statementsKey], guid)
   if (!claim) throw new Error(`claim not found: ${guid}`)
-  if (simplifyOption) claim = simplify.claim(claim, options)
+  if (simplifyOption) claim = simplifyClaim(claim, options)
   output(claim)
 }
 

package/lib/fetch_and_log_ids_data.js

@@ -1,20 +1,21 @@
-const program = require('./program')
-require('./exit_on_missing').instance(program.instance)
-const { simplify, isEntitySchemaId } = require('./wbk')(program)
-const logNdjson = require('./log_ndjson')
-const getTtlEntities = require('./get_ttl_entities')
-const getEntitiesSchemas = require('./get_entities_schemas')
-const parseProps = require('./parse_props')
-const dropNonSelectedSubprops = require('./drop_non_selected_subprops')
-const getEntitiesByBatches = require('./get_entities_by_batches')
+import { isEntitySchemaId, simplifyEntity } from 'wikibase-sdk'
+import { exitOnMissingInstance } from '#lib/exit_on_missing'
+import optionsFactory from '#lib/parse_simplify_options'
+import dropNonSelectedSubprops from './drop_non_selected_subprops.js'
+import { getEntitiesByBatches } from './get_entities_by_batches.js'
+import { getEntitiesSchemas } from './get_entities_schemas.js'
+import getTtlEntities from './get_ttl_entities.js'
+import logNdjson from './log_ndjson.js'
+import parseProps from './parse_props.js'
+import program from './program.js'
 
-const requestedPropsAndSubProps = parseProps(program.props)
-const requestedProps = Object.keys(requestedPropsAndSubProps)
+export function fetchAndLogIdsData (ids) {
+  exitOnMissingInstance(program.instance)
+  const requestedPropsAndSubProps = parseProps(program.props)
+  const requestedProps = Object.keys(requestedPropsAndSubProps)
+  const options = optionsFactory(program)
+  const { simplify: simplifyFlag, format } = program
 
-const options = require('../lib/parse_simplify_options')(program)
-const { simplify: simplifyFlag, format } = program
-
-module.exports = ids => {
   if (format === 'ttl') return getTtlEntities(ids)
 
   const entitiesSchemasIds = ids.filter(isEntitySchemaId)
@@ -24,7 +25,7 @@ module.exports = ids => {
   const onResponse = entities => {
     entities.forEach(entity => dropNonSelectedSubprops(entity, requestedPropsAndSubProps))
     if (simplifyFlag) {
-      entities = entities.map(entity => simplify.entity(entity, options))
+      entities = entities.map(entity => simplifyEntity(entity, options))
     }
     logNdjson(entities)
   }

package/lib/fetch_and_log_property_claims_data.js

@@ -1,19 +1,27 @@
-const { get } = require('../lib/request')
-const program = require('./program')
-require('../lib/exit_on_missing').instance(program.instance)
-const { getEntities, simplify } = require('../lib/wbk')(program)
-const options = require('../lib/parse_simplify_options')(program)
-const { simplify: simplifyOption } = program
-const output = require('./output')(program)
+import { getStatementsKey } from 'wikibase-edit/lib/parse_instance.js'
+import { simplifyPropertyClaims } from 'wikibase-sdk'
+import { exitOnMissingInstance } from '#lib/exit_on_missing'
+import optionsFactory from '#lib/parse_simplify_options'
+import { get } from '#lib/request'
+import wbk from '#lib/wbk'
+import { outputFactory } from './output.js'
+import program from './program.js'
+
+export async function fetchAndLogPropertyClaimsData (propertyClaimsId) {
+  exitOnMissingInstance(program.instance)
+  const { getEntities } = wbk(program)
+  const options = optionsFactory(program)
+  const { simplify: simplifyOption } = program
+  const output = outputFactory(program)
 
-module.exports = async propertyClaimsId => {
   const [ entityId, propertyId ] = propertyClaimsId.toUpperCase().split('#')
   const url = getEntities({ ids: entityId, props: 'claims' })
 
   const { entities } = await get(url)
   const entity = entities[entityId]
   if (entity.missing != null) throw new Error(`entity not found: ${entityId}`)
-  let claims = entity.claims[propertyId] || []
-  if (simplifyOption) claims = simplify.propertyClaims(claims, options)
+  const statementsKey = getStatementsKey(program.instance)
+  let claims = entity[statementsKey][propertyId] || []
+  if (simplifyOption) claims = simplifyPropertyClaims(claims, options)
   output(claims)
 }

package/lib/fetch_lang_props.js

@@ -1,23 +1,24 @@
-const { red, yellow } = require('chalk')
-const { get } = require('../lib/request')
-const valide = require('../lib/valide')
-const exitOnMissing = require('./exit_on_missing')
-const WBK = require('../lib/wbk')
-const queryAllProperties = require('./queries/all_properties')
+import { simplifySparqlResults } from 'wikibase-sdk'
+import { red, yellow } from '#lib/chalk'
+import { get } from '#lib/request'
+import { isValidLang } from '#lib/validate'
+import wbk from '#lib/wbk'
+import { exitOnMissingSparqlEndpoint } from './exit_on_missing.js'
+import queryAllProperties from './queries/all_properties.js'
 
-module.exports = async program => {
+export default async program => {
   const { lang, sparqlEndpoint } = program
-  exitOnMissing.sparqlEndpoint(program.sparqlEndpoint)
-  const { sparqlQuery, simplify } = WBK(program)
+  exitOnMissingSparqlEndpoint(program.sparqlEndpoint)
+  const { sparqlQuery } = wbk(program)
 
-  if (!valide.lang(lang)) throw Error(red(`invalid language: ${lang}`))
+  if (!isValidLang(lang)) throw Error(red(`invalid language: ${lang}`))
 
   const sparql = queryAllProperties(lang)
   const url = sparqlQuery(sparql)
 
   try {
     const body = await get(url)
-    return simplify.sparqlResults(body).reduce(aggregator, {})
+    return simplifySparqlResults(body).reduce(aggregator, {})
   } catch (err) {
     if (err.name === 'SyntaxError' || err.statusCode === 404) {
       console.error(yellow(`Are you sure ${sparqlEndpoint} is a valid SPARQL endpoint?`))
@@ -36,7 +37,7 @@ const aggregator = (map, prop) => {
     label: noLabelFound ? undefined : label,
     type: type.split('#')[1],
     description,
-    aliases
+    aliases,
   }
   return map
 }

package/lib/filter_claims_properties.js

@@ -1,14 +1,14 @@
-const getPatternFilter = require('./get_pattern_filter')
-const commonErrors = require('./common_errors')
+import { missingProperty } from './common_errors.js'
+import getPatternFilter from './get_pattern_filter.js'
 
-module.exports = (propertiesData, claims, pattern) => {
+export default (propertiesData, claims, pattern) => {
   const patternFilter = getPatternFilter(pattern, true)
 
   const filteredClaims = {}
 
   Object.keys(claims).forEach(property => {
     const propData = propertiesData[property]
-    if (!propData) return commonErrors.missingProperty(property)
+    if (!propData) return missingProperty(property)
     if (patternFilter(propData)) filteredClaims[property] = claims[property]
   })
 

package/lib/format_properties_data.js

@@ -1,6 +1,6 @@
-const { isPropertyId } = require('wikibase-sdk')
+import { isPropertyId } from 'wikibase-sdk'
 
-module.exports = (pattern, filter, includeAllDetails, includeTypes) => data => {
+export default (pattern, filter, includeAllDetails, includeTypes) => data => {
   // Special case: when the pattern is a property id, just log the property
   if (isPropertyId(pattern) && data[pattern] != null) {
     const prop = pattern

package/lib/format_statement_element_value.js

@@ -1,5 +1,5 @@
-const { isEntityId, isPropertyId } = require('wikibase-sdk')
-const errors_ = require('../lib/errors')
+import { isEntityId, isPropertyId } from 'wikibase-sdk'
+import errors_ from '#lib/errors'
 
 const prefixedProperty = prefix => value => {
   if (isPropertyId(value)) return `${prefix}:${value}`
@@ -20,7 +20,7 @@ const object = value => {
   return `"${value}"`.replace(/""/g, '"')
 }
 
-module.exports = {
+export default {
   subject: value => {
     if (isEntityId(value)) return `wd:${value}`
     if (isUrlValue(value)) return formatUrlValue(value)

package/lib/fs.js

@@ -1,28 +1,30 @@
-const fs = require('fs')
-const mkdirp = require('mkdirp')
+import fs from 'node:fs'
+import mkdirp from 'mkdirp'
 
-module.exports = {
-  writeFile: (filepath, content) => {
-    return new Promise((resolve, reject) => {
-      fs.writeFile(filepath, content, (err, res) => {
-        err ? reject(err) : resolve(res)
-      })
+export const writeFile = (filepath, content) => {
+  return new Promise((resolve, reject) => {
+    fs.writeFile(filepath, content, (err, res) => {
+      err ? reject(err) : resolve(res)
     })
-  },
-  exists: path => {
-    return new Promise((resolve, reject) => {
-      fs.access(path, (err, res) => err ? reject(err) : resolve(res))
-    })
-  },
-  createFolder: path => {
-    return new Promise((resolve, reject) => {
-      mkdirp(path, err => err ? reject(err) : resolve())
-    })
-  },
-  writeAccessSync: path => {
-    // Testing right to write
-    // cf https://nodejs.org/api/fs.html#fs_fs_access_path_mode_callback
-    // Will throw if failing
-    fs.accessSync(path, fs.constants.W_OK)
-  }
+  })
+}
+export const exists = path => {
+  return new Promise((resolve, reject) => {
+    fs.access(path, (err, res) => err ? reject(err) : resolve(res))
+  })
+}
+export const createFolder = path => {
+  return new Promise((resolve, reject) => {
+    mkdirp(path, err => err ? reject(err) : resolve())
+  })
+}
+export const writeAccessSync = path => {
+  // Testing right to write
+  // cf https://nodejs.org/api/fs.html#fs_fs_access_path_mode_callback
+  // Will throw if failing
+  fs.accessSync(path, fs.constants.W_OK)
+}
+
+export function getDirname (fileUrl) {
+  return new URL('.', fileUrl).pathname
 }

package/lib/generate_describe_sparql_query.js

@@ -1,7 +1,7 @@
-const { isEntityId } = require('wikibase-sdk')
-const errors_ = require('./errors')
+import { isEntityId } from 'wikibase-sdk'
+import errors_ from './errors.js'
 
-module.exports = describe => {
+export function generateDescribeSparqlQuery (describe) {
   if (describe.startsWith('http')) return `DESCRIBE <${describe}>`
   if (isEntityId(describe)) return `DESCRIBE wd:${describe}`
   throw errors_.new('could not identify describe node type', 400, { describe })

package/lib/generate_sample_sparql_query.js

@@ -1,4 +1,4 @@
-module.exports = (limit = 1000) => {
+export function generateSampleSparqlQuery (limit = 1000) {
   return `SELECT * {
   ?s ?p ?o .
 }

package/lib/generate_select_sparql_query.js

@@ -1,6 +1,6 @@
-const formatStatementElementValue = require('./format_statement_element_value')
+import formatStatementElementValue from './format_statement_element_value.js'
 
-module.exports = program => {
+export function generateSelectSparqlQuery (program) {
   let { count: countResults, labels: selectLabels, lang, qualifierProperty, qualifierObject } = program
 
   const useSubSnaks = (qualifierProperty != null || qualifierObject != null)
@@ -56,9 +56,12 @@ module.exports = program => {
   setElement('object')
 
   if (selectLabels) {
-    if (lang !== 'en') {
-      // include English as a fallback
-      lang = `${lang},en`
+    // Include [AUTO_LANGUAGE], especially useful if program.open === true
+    if (lang === 'en') {
+      lang = 'en,[AUTO_LANGUAGE]'
+    } else {
+      // Include English as a fallback
+      lang = `${lang},[AUTO_LANGUAGE],en`
     }
     triple += `
   SERVICE wikibase:label {
@@ -71,7 +74,7 @@ module.exports = program => {
   let sparql = `SELECT ${select.trim()} WHERE {
   ${triple}
 }`
-  if (limit) sparql += ` LIMIT ${limit}`
+  if (limit) sparql += `\nLIMIT ${limit}`
 
   return sparql
 }

package/lib/get_cache_folder_path.js

@@ -1,12 +1,12 @@
-const fs = require('./fs')
-const getFolderPath = require('./get_folder_path')
+import { exists, createFolder } from './fs.js'
+import getFolderPath from './get_folder_path.js'
 
-module.exports = subfolder => {
+export default subfolder => {
   const subfolderPath = getFolderPath('cache', subfolder)
-  return fs.exists(subfolderPath)
+  return exists(subfolderPath)
   .catch(err => {
     if (err.code === 'ENOENT') {
-      return fs.createFolder(subfolderPath)
+      return createFolder(subfolderPath)
     } else {
       throw err
     }

package/lib/get_claims_texts.js

@@ -1,11 +1,12 @@
-const chalk = require('chalk')
+import chalk from 'chalk'
+import { isEntityId } from 'wikibase-sdk'
+import { missingProperty } from './common_errors.js'
+import getPropertiesData from './get_properties_data.js'
+import { propTypes } from './properties.js'
+
 const { grey, bgWhite, black } = chalk
-const { isEntityId } = require('wikibase-sdk')
-const { propTypes } = require('./properties')
-const commonErrors = require('./common_errors')
-const getPropertiesData = require('./get_properties_data')
 
-module.exports = async ({ labels, simplifiedClaims, resort, lang }) => {
+export default async ({ labels, simplifiedClaims, resort, lang }) => {
   const propertiesIds = Object.keys(simplifiedClaims)
   const propertiesData = await getPropertiesData(propertiesIds, lang)
 
@@ -17,7 +18,7 @@ module.exports = async ({ labels, simplifiedClaims, resort, lang }) => {
 
 const buildClaimsText = (labels, prop, values, propertiesData) => {
   const propData = propertiesData[prop]
-  if (!propData) return commonErrors.missingProperty(prop)
+  if (!propData) return missingProperty(prop)
 
   const { label, type } = propData
   const propColor = propTypes[type].color

package/lib/get_entities.js

@@ -1,10 +1,11 @@
-const { get } = require('./request')
-const program = require('./program')
+import wbk from '#lib/wbk'
+import program from './program.js'
+import { get } from './request.js'
 
-module.exports = async params => {
+export default async params => {
   // JIT require to be sure program.process was already called
-  // and program.intance is set
-  const { getManyEntities } = require('./wbk')(program)
+  // and program.instance is set
+  const { getManyEntities } = wbk(program)
 
   const urls = getManyEntities(params)
   const allEntities = {}