@dbmx/toasts 0.0.122 → 0.0.124

package/cjs/node_modules/@dbmx/sdmx/esm/query.cjs

@@ -0,0 +1,151 @@
+'use strict';
+
+var urlJoin = require('./node_modules/url-join/lib/url-join.cjs');
+var is = require('./node_modules/ramda/es/is.cjs');
+
+const OPERATORS = ['eq', 'ne', 'lt', 'le', 'gt', 'ge', 'co', 'nc', 'sw', 'ew'];
+
+const makeComponentFilter = input => {
+  if (is(String, input)) return input
+  if (Object.keys(input).length === 1) {
+    const [op, value] = [Object.keys(input)[0], Object.values(input)[0]];
+    if (op === 'and') {
+      if (!is(Array, value)) throw new Error(`Wrong value type for operator ${op}: must be an Array`)
+      return value.map(makeComponentFilter).join('+')
+    }
+    if (op === 'or') {
+      if (!is(Array, value)) throw new Error(`Wrong value type for operator ${op}: must be an Array`)
+      return value.map(makeComponentFilter).join(',')
+    }
+    if (!OPERATORS.includes(op)) throw new Error(`Wrong operator ${op}`)
+    return `${op}:${value}`
+  }
+
+  return makeComponentFilter({ and: Object.keys(input).map(key => ({ [key]: input[key] })) })
+};
+
+const makeCFilter = (c = {}) => {
+  const filter = {};
+  for (const key of Object.keys(c)) {
+    const value = c[key];
+    if (is(Array, value)) throw new Error(`wrong syntax for key "${key}: ${JSON.stringify(value)}"`)
+    else filter[key] = makeComponentFilter(value);
+  }
+  return filter
+};
+
+const makeCParams = obj => {
+  const res = new URLSearchParams();
+  for (const key of Object.keys(obj)) {
+    const param = `c[${key}]`;
+    res.set(param, obj[key]);
+  }
+  return res
+};
+
+/**
+ * @typedef DataQuery
+ * @property {string} - context ('dataflow' by default)
+ * @property {string} - agencyID
+ * @property {string} - resourceID
+ * @property {string} - id
+ * @property {string} - version ('~' by default)
+ * @property {string} - endpoint
+ * @property {array | string} - dimensionAtObservation ('AllDimensions' by default)
+ * @property {object} - c
+ * @property {string} - key
+ * @property {array | string} - attributes - 'all' | 'none' | Array with specified attributes
+ * @property {array | string} - measures - 'all' | 'none' | Array with specified measures
+ * @property {string} - rmin - Minimum data rows to return
+ * @property {string} - rmax - Maximum data rows to return
+ * @property {string} - format - Result format to be returned (JSON - CSV - XML)
+ */
+
+/**
+ * Returns a URL for querying SDMX data based on the provided parameters.
+ *
+ * @function dataQueryUrl
+ * @tag query
+ * @param {DataQuery} - The data query parameters
+ * @return {string} - Returns the constructed URL for querying SDMX data
+ * @throws {Error} Throws an error if required parameters are missing
+
+ *
+ * @example
+ *
+ *   const query = {
+ *     context: 'dataflow',
+ *     agencyID: 'AGENCY',
+ *     id: 'ID',
+ *     version: '1.2.3-draft',
+ *     endpoint: 'https://sxs-staging-orox.dbmx.io/demo/sdmx',
+ *     dimensionAtObservation: 'AllDimensions',
+ *     attributes: ['OATTR4', 'OATTR6'],
+ *     measures: 'none',
+ *     key: 'M.*.EUR.SP00.A',
+ *     c: {
+ *       // INDICATOR: { or: ['MRY0T4','TMY5T9','TMY10T14','TMY15T24']},
+ *       INDICATOR: 'MRY0T4,TMY5T9,TMY10T14,TMY15T24',
+ *       SEX: '_T',
+ *       WEALTH_QUINTILE: '_T',
+ *       REF_AREA: 'AFG,AGO',
+ *       TIME_PERIOD: 'ge:2020-06+le:2020-06',
+ *       TIME_PERIOD1: { ge: '2020-06', le: '2020-06' },
+ *       ATTR1: { and: [{ ge: '2020-06' }, { le: '2020-06' }] },
+ *       ATTR2: { or: [{ co: 'toto' }, { and: [{ ge: '2020-06' }, { le: '2020-06' }] }] },
+ *       ATTR3: { or: [{ co: 'toto' }, { ge: '2020-06', le: '2020-06' }] },
+ *     },
+ *   }
+ *   const res = dataQueryUrl(query)
+ *   expect(res).toEqual(
+ *     'https://sxs-staging-orox.dbmx.io/demo/sdmx/data/dataflow/AGENCY/ID/1.2.3-draft/M.*.EUR.SP00.A?c%5BINDICATOR%5D=MRY0T4%2CTMY5T9%2CTMY10T14%2CTMY15T24&c%5BSEX%5D=_T&c%5BWEALTH_QUINTILE%5D=_T&c%5BREF_AREA%5D=AFG%2CAGO&c%5BTIME_PERIOD%5D=ge%3A2020-06%2Ble%3A2020-06&c%5BTIME_PERIOD1%5D=ge%3A2020-06%2Ble%3A2020-06&c%5BATTR1%5D=ge%3A2020-06%2Ble%3A2020-06&c%5BATTR2%5D=co%3Atoto%2Cge%3A2020-06%2Ble%3A2020-06&c%5BATTR3%5D=co%3Atoto%2Cge%3A2020-06%2Ble%3A2020-06&attributes=OATTR4,OATTR6&measures=none&dimensionAtObservation=AllDimensions',
+ *   )
+ *
+ */
+
+const dataQueryUrl = ({
+  context = 'dataflow',
+  agencyID,
+  resourceID,
+  id,
+  version = '~',
+  endpoint,
+  dimensionAtObservation = 'AllDimensions',
+  c,
+  key,
+  attributes,
+  measures,
+  rmin,
+  rmax,
+  format,
+}) => {
+  if (!endpoint) throw new Error(`Cannot create structure query URL without an endpoint`)
+  if (!agencyID) throw new Error(`Cannot create structure query URL without an agencyID`)
+  if (!(resourceID || id)) throw new Error(`Cannot create structure query URL without a resourceID`)
+  const params = [endpoint, '/data', context, agencyID, resourceID || id, version];
+
+  if (key) params.push(key);
+  try {
+    if (c) params.push(`?${makeCParams(makeCFilter(c))}`);
+  } catch (err) {
+    console.error(`Cannot make CFilter for ${JSON.stringify(c, null, 4)}`);
+    console.error(err);
+  }
+  if (attributes) {
+    if (is(String, attributes)) params.push(`?attributes=${attributes}`);
+    else params.push(`?attributes=${attributes.join(',')}`);
+  }
+  if (measures) {
+    if (is(String, measures)) params.push(`?measures=${measures}`);
+    else params.push(`?measures=${measures.join(',')}`);
+  }
+  if (dimensionAtObservation) params.push(`?dimensionAtObservation=${dimensionAtObservation}`);
+  if (rmin) params.push(`?rmin=${rmin}`);
+  if (rmax) params.push(`?rmax=${rmax}`);
+  if (format) params.push(`?format=${format}`);
+
+  return urlJoin(...params)
+};
+
+exports.dataQueryUrl = dataQueryUrl;
+exports.makeCFilter = makeCFilter;

package/cjs/node_modules/@dbmx/sdmx/esm/types/artefacts.cjs

@@ -0,0 +1,33 @@
+'use strict';
+
+var dataflow = require('./dataflow.cjs');
+var datastructure = require('./datastructure.cjs');
+var codelist = require('./codelist.cjs');
+var categorisation = require('./categorisation.cjs');
+var categoryscheme = require('./categoryscheme.cjs');
+var conceptscheme = require('./conceptscheme.cjs');
+var contentconstraint = require('./contentconstraint.cjs');
+var dataproviderscheme = require('./dataproviderscheme.cjs');
+var hierarchicalcodelist = require('./hierarchicalcodelist.cjs');
+var dataconstraint = require('./dataconstraint.cjs');
+var provisionagreement = require('./provisionagreement.cjs');
+var metadatastructure = require('./metadatastructure.cjs');
+var metadataflow = require('./metadataflow.cjs');
+
+const Artefacts = [
+  dataflow,
+  datastructure,
+  codelist,
+  categorisation,
+  categoryscheme,
+  conceptscheme,
+  contentconstraint,
+  dataconstraint,
+  dataproviderscheme,
+  hierarchicalcodelist,
+  provisionagreement,
+  metadatastructure,
+  metadataflow,
+];
+
+exports.Artefacts = Artefacts;

package/cjs/node_modules/@dbmx/sdmx/esm/types/categorisation.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var identity = require('../node_modules/ramda/es/identity.cjs');
+
+function getChildRefs(input) {
+  return [core.urn2FullRef(input.source), core.urn2FullRef(input.target)].filter(identity)
+}
+
+var Categorisation = sdmx.Artefact({
+  name: 'categorisation',
+  structureName: 'categorisations',
+  packageName: 'categoryscheme',
+  className: 'Categorisation',
+  getChildRefs,
+});
+
+module.exports = Categorisation;

package/cjs/node_modules/@dbmx/sdmx/esm/types/categoryscheme.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+
+var CategoryScheme = sdmx.ItemScheme({
+  name: 'categoryscheme',
+  structureName: 'categorySchemes',
+  packageName: 'categoryscheme',
+  className: 'CategoryScheme',
+  itemsName: 'categories',
+});
+
+module.exports = CategoryScheme;

package/cjs/node_modules/@dbmx/sdmx/esm/types/codelist.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+
+function getChildRefs(input) {
+  return (input.codelistExtensions || []).map(ext => core.urn2FullRef(ext.codelist))
+}
+
+var Codelist = sdmx.ItemScheme({
+  name: 'codelist',
+  structureName: 'codelists',
+  packageName: 'codelist',
+  className: 'Codelist',
+  itemsName: 'codes',
+  getChildRefs,
+});
+
+module.exports = Codelist;

package/cjs/node_modules/@dbmx/sdmx/esm/types/conceptscheme.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var propOr = require('../node_modules/ramda/es/propOr.cjs');
+
+const getCoreRepresentations = input => {
+  const refs = [];
+  for (const concept of propOr([], 'concepts', input)) {
+    const enumeration = concept.coreRepresentation?.enumeration;
+    if (enumeration) refs.push(core.urn2FullRef(enumeration));
+  }
+  return refs
+};
+
+function getChildRefs(input) {
+  return getCoreRepresentations(input)
+}
+
+var ConcepScheme = sdmx.ItemScheme({
+  name: 'conceptscheme',
+  structureName: 'conceptSchemes',
+  packageName: 'conceptscheme',
+  className: 'ConceptScheme',
+  itemsName: 'concepts',
+  getChildRefs,
+});
+
+module.exports = ConcepScheme;

package/cjs/node_modules/@dbmx/sdmx/esm/types/contentconstraint.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var reduce = require('../node_modules/ramda/es/reduce.cjs');
+var map = require('../node_modules/ramda/es/map.cjs');
+var values = require('../node_modules/ramda/es/values.cjs');
+
+function getChildRefs(input) {
+  const { constraintAttachment = {} } = input;
+  return reduce((acc, urns) => [...acc, ...map(urn => core.urn2FullRef(urn), urns)], [], values(constraintAttachment))
+}
+
+var ContentConstraint = sdmx.Artefact({
+  structureName: 'contentConstraints',
+  name: 'contentconstraint',
+  packageName: 'registry',
+  className: 'ContentConstraint',
+  version: 2,
+  getChildRefs,
+});
+
+module.exports = ContentConstraint;

package/cjs/node_modules/@dbmx/sdmx/esm/types/dataconstraint.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var reduce = require('../node_modules/ramda/es/reduce.cjs');
+var map = require('../node_modules/ramda/es/map.cjs');
+var values = require('../node_modules/ramda/es/values.cjs');
+
+function getChildRefs(input) {
+  const { constraintAttachment = {} } = input;
+  return reduce((acc, urns) => [...acc, ...map(urn => core.urn2FullRef(urn), urns)], [], values(constraintAttachment))
+}
+
+var DataConstraint = sdmx.Artefact({
+  structureName: 'dataConstraints',
+  name: 'dataconstraint',
+  packageName: 'registry',
+  className: 'DataConstraint',
+  getChildRefs,
+});
+
+module.exports = DataConstraint;

package/cjs/node_modules/@dbmx/sdmx/esm/types/dataflow.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+
+function getChildRefs(input) {
+  if (input.isExternalReference) return []
+  if (!input.structure) return []
+  return [core.urn2FullRef(input.structure)]
+}
+
+var Dataflow = sdmx.Artefact({
+  name: 'dataflow',
+  structureName: 'dataflows',
+  packageName: 'datastructure',
+  className: 'Dataflow',
+  getChildRefs,
+});
+
+module.exports = Dataflow;

package/cjs/node_modules/@dbmx/sdmx/esm/types/dataproviderscheme.cjs

@@ -0,0 +1,13 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+
+var DataProviderScheme = sdmx.ItemScheme({
+  structureName: 'dataProviderSchemes',
+  name: 'dataproviderscheme',
+  packageName: 'base',
+  className: 'DataProviderScheme',
+  itemsName: 'dataProviders',
+});
+
+module.exports = DataProviderScheme;

package/cjs/node_modules/@dbmx/sdmx/esm/types/datastructure.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var compose = require('../node_modules/ramda/es/compose.cjs');
+var map = require('../node_modules/ramda/es/map.cjs');
+var pathOr = require('../node_modules/ramda/es/pathOr.cjs');
+var reduce = require('../node_modules/ramda/es/reduce.cjs');
+var is = require('../node_modules/ramda/es/is.cjs');
+var forEach = require('../node_modules/ramda/es/forEach.cjs');
+
+const collect = (res, name, value) => {
+  if (!value) return
+  const newValue = is(Array, value) ? value : [value];
+  if (!res[name]) res[name] = new Set(newValue);
+  else forEach(v => res[name].add(v), newValue);
+};
+
+const collectAll = (res, { conceptIdentity, localRepresentation, conceptRoles = [] }) => {
+  collect(res, 'conceptschemeRefs', core.urn2FullRef(conceptIdentity));
+  collect(res, 'conceptschemeRefs', map(core.urn2FullRef, conceptRoles));
+  collect(res, 'codelistRefs', core.urn2FullRef(localRepresentation?.enumeration));
+};
+
+const analyseComponent =
+  path =>
+  ([data, res]) => {
+    collectAll(res, pathOr({}, path, data));
+    return [data, res]
+  };
+
+const analyseComponents =
+  path =>
+  ([data, res]) =>
+    [
+      data,
+      reduce(
+        (acc, component) => {
+          collectAll(res, component);
+          return acc
+        },
+        res,
+        pathOr([], path, data),
+      ),
+    ];
+
+const analyseDataStructureComponents = ({ dataStructureComponents }) =>
+  compose(
+    ([, res]) => map(x => [...x], res),
+    analyseComponents(['attributeList', 'attributes']),
+    analyseComponents(['dimensionList', 'dimensions']),
+    analyseComponents(['dimensionList', 'measureDimensions']),
+    analyseComponent(['dimensionList', 'timeDimension']),
+    analyseComponents(['dimensionList', 'timeDimensions']), // v2
+    analyseComponents(['measureList', 'measures']),
+    analyseComponent(['measureList', 'primaryMeasure']), // v2
+  )([dataStructureComponents, {}]);
+
+function getChildRefs(input) {
+  const analyse = analyseDataStructureComponents(input);
+  const res = [...(analyse.conceptschemeRefs || []), ...(analyse.codelistRefs || [])];
+  if (input.metadata) res.push(core.urn2FullRef(input.metadata));
+  return res
+}
+
+var Datastructure = sdmx.Artefact({
+  name: 'datastructure',
+  structureName: 'dataStructures',
+  packageName: 'datastructure',
+  className: 'DataStructure',
+  getChildRefs,
+});
+
+module.exports = Datastructure;

package/cjs/node_modules/@dbmx/sdmx/esm/types/hierarchicalcodelist.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var map = require('../node_modules/ramda/es/map.cjs');
+var values = require('../node_modules/ramda/es/values.cjs');
+
+function getChildRefs(input) {
+  const { includedCodelists = {} } = input;
+  return map(urn => core.urn2FullRef(urn), values(includedCodelists))
+}
+
+var HierarchicalCodelist = sdmx.Artefact({
+  structureName: 'hierarchicalCodelists',
+  name: 'hierarchicalcodelist',
+  packageName: 'codelist',
+  className: 'HierarchicalCodelist',
+  version: 2,
+  getChildRefs,
+});
+
+module.exports = HierarchicalCodelist;

package/cjs/node_modules/@dbmx/sdmx/esm/types/metadataflow.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+
+function getChildRefs(input) {
+  if (input.isExternalReference) return []
+  if (!input.structure) return []
+  return [core.urn2FullRef(input.structure)]
+}
+
+var MetaDataflow = sdmx.Artefact({
+  name: 'metadataflow',
+  structureName: 'metadataflows',
+  packageName: 'metadatastructure',
+  className: 'MetaDataflow',
+  getChildRefs,
+});
+
+module.exports = MetaDataflow;

package/cjs/node_modules/@dbmx/sdmx/esm/types/metadatastructure.cjs

@@ -0,0 +1,58 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var compose = require('../node_modules/ramda/es/compose.cjs');
+var map = require('../node_modules/ramda/es/map.cjs');
+var reduce = require('../node_modules/ramda/es/reduce.cjs');
+var pathOr = require('../node_modules/ramda/es/pathOr.cjs');
+var is = require('../node_modules/ramda/es/is.cjs');
+var forEach = require('../node_modules/ramda/es/forEach.cjs');
+
+const collect = (res, name, value) => {
+  if (!value) return
+  const newValue = is(Array, value) ? value : [value];
+  if (!res[name]) res[name] = new Set(newValue);
+  else forEach(v => res[name].add(v), newValue);
+};
+
+const collectAll = (res, { conceptIdentity, localRepresentation }) => {
+  collect(res, 'conceptschemeRefs', core.urn2FullRef(conceptIdentity));
+  collect(res, 'codelistRefs', core.urn2FullRef(localRepresentation?.enumeration));
+};
+
+const analyseComponents =
+  path =>
+  ([data, res]) =>
+    [
+      data,
+      reduce(
+        (acc, component) => {
+          collectAll(res, component);
+          return acc
+        },
+        res,
+        pathOr([], path, data),
+      ),
+    ];
+
+const analyseDataStructureComponents = ({ metadataStructureComponents }) =>
+  compose(
+    ([, res]) => map(x => [...x], res),
+    analyseComponents(['metadataAttributeList', 'metadataAttributes']),
+  )([metadataStructureComponents, {}]);
+
+function getChildRefs(input) {
+  const analyse = analyseDataStructureComponents(input);
+  return [...(analyse.conceptschemeRefs || []), ...(analyse.codelistRefs || [])]
+}
+
+var MetadataStructure = sdmx.Artefact({
+  name: 'metadatastructure',
+  structureName: 'metadataStructures',
+  packageName: 'metadatastructure',
+  className: 'MetadataStructure',
+  getChildRefs,
+});
+
+module.exports = MetadataStructure;

package/cjs/node_modules/@dbmx/sdmx/esm/types/provisionagreement.cjs

@@ -0,0 +1,19 @@
+'use strict';
+
+var sdmx = require('./sdmx.cjs');
+var core = require('../core.cjs');
+var identity = require('../node_modules/ramda/es/identity.cjs');
+
+function getChildRefs(input) {
+  return [core.urn2FullRef(input.structureUsage), core.urn2FullRef(input.dataProvider)].filter(identity)
+}
+
+var ProvisionAgreement = sdmx.Artefact({
+  structureName: 'provisionAgreements',
+  name: 'provisionagreement',
+  packageName: 'registry',
+  className: 'ProvisionAgreement',
+  getChildRefs,
+});
+
+module.exports = ProvisionAgreement;

package/cjs/node_modules/@dbmx/sdmx/esm/types/sdmx.cjs

@@ -0,0 +1,51 @@
+'use strict';
+
+const SDMX = ({ name, packageName, className, version }) => {
+  const self = { name, packageName, className };
+  if (version) self.version = version;
+  return self
+};
+
+function defaultGetChildRefs() {
+  return []
+}
+
+const Artefact = ({ structureName, getChildRefs, ...props }) => {
+  const self = SDMX(props);
+  self.type = 'artefact';
+  self.resourceType = self.name;
+  self.structureName = structureName;
+  self.getChildRefs = getChildRefs ? getChildRefs.bind(self) : defaultGetChildRefs;
+  self.isArtefact = true;
+  return self
+};
+
+const ItemScheme = ({ itemsName, ...props }) => {
+  const self = Artefact(props);
+  self.itemsName = itemsName;
+  self.isItemScheme = true;
+  return self
+};
+
+const Item = ({ schemeName, ...props }) => {
+  const self = SDMX(props);
+  self.type = 'item';
+  self.resourceType = self.name;
+  self.schemeName = schemeName ?? self.packageName;
+  self.isItem = true;
+  return self
+};
+
+const Component = ({ schemeName, ...props }) => {
+  const self = SDMX(props);
+  self.type = 'component';
+  self.schemeName = schemeName ?? self.packageName;
+  self.isComponent = true;
+  return self
+};
+
+exports.Artefact = Artefact;
+exports.Component = Component;
+exports.Item = Item;
+exports.ItemScheme = ItemScheme;
+exports.SDMX = SDMX;