@data-fair/catalog-onegeo-suite 0.1.0

package/README.md

@@ -0,0 +1,3 @@
+# <img alt="Data FAIR logo" src="https://cdn.jsdelivr.net/gh/data-fair/data-fair@master/ui/public/assets/logo.svg" width="40"> @data-fair/catalog-onegeo-suite
+
+A simple OneGeoSuite plugin for the Data Fair catalogs service.

package/index.ts

@@ -0,0 +1,37 @@
+import type CatalogPlugin from '@data-fair/types-catalogs'
+import { importConfigSchema, configSchema, assertConfigValid, type OneGeoSuiteConfig } from '#types'
+import { type OneGeoCapabilities, capabilities } from './lib/capabilities.ts'
+import i18n from './lib/i18n.ts'
+
+// Since the plugin is very frequently imported, each function is imported on demand,
+// instead of loading the entire plugin.
+// This file should not contain any code, but only constants and dynamic imports of functions.
+
+const plugin: CatalogPlugin<OneGeoSuiteConfig, OneGeoCapabilities> = {
+  async prepare (context) {
+    const prepare = (await import('./lib/prepare.ts')).default
+    return prepare(context)
+  },
+
+  async list (context) {
+    const { list } = await import('./lib/list.ts')
+    return list(context)
+  },
+
+  async getResource (context) {
+    const { getResource } = await import('./lib/imports.ts')
+    return getResource(context)
+  },
+
+  metadata: {
+    title: 'OneGeoSuite',
+    thumbnailPath: './lib/resources/thumbnail.svg',
+    i18n,
+    capabilities
+  },
+
+  importConfigSchema,
+  configSchema,
+  assertConfigValid
+}
+export default plugin

package/lib/capabilities.ts

@@ -0,0 +1,19 @@
+import type { Capability } from '@data-fair/types-catalogs'
+
+/**
+ * The list of capabilities of the plugin.
+ * These capabilities define the actions that can be performed with the plugin.
+ * The capabilities must satisfy the `Capability` type.
+ */
+export const capabilities = [
+  'thumbnail',
+  'search',
+  'pagination',
+
+  'import',
+  'importConfig',
+
+] satisfies Capability[]
+
+export type OneGeoCapabilities = typeof capabilities
+export default capabilities

package/lib/i18n.ts

@@ -0,0 +1,52 @@
+import type { Metadata } from '@data-fair/types-catalogs'
+
+const i18n: Metadata['i18n'] = {
+  en: {
+    description: 'This catalog allows testing the service by simulating a folder and file structure.',
+    actionLabels: {
+      // createFolderInRoot: 'Create folder in root',
+      // createFolder: 'Create folder',
+      createResource: 'Create file', // Default : Create resource
+      // replaceFolder: 'Replace folder',
+      replaceResource: 'Replace file' // Default : Replace resource
+    },
+    actionButtons: {
+      // createFolderInRoot: 'Create publication',
+      // createFolder: 'Create publication here',
+      createResource: 'Create file here', // Default : Create publication here
+      // replaceFolder: 'Replace this folder',
+      replaceResource: 'Replace file' // Default : Replace this resource
+    },
+    stepTitles: {
+      // createFolder: 'Destination folder selection',
+      // createResource: 'Destination folder selection',
+      // replaceFolder: 'Folder to replace selection',
+      replaceResource: 'File to replace selection' // Default : Resource to replace selection
+    }
+  },
+  fr: {
+    description: 'Ce catalogue permet de tester le service en simulant une arborescence de dossiers et de fichiers.',
+    actionLabels: {
+      // createFolderInRoot: 'Créer un dossier à la racine',
+      // createFolder: 'Créer un dossier',
+      createResource: 'Créer un fichier', // Défaut : Créer une ressource
+      // replaceFolder: 'Écraser un dossier',
+      replaceResource: 'Remplacer un fichier' // Défaut : Écraser une ressource
+    },
+    actionButtons: {
+      // createFolderInRoot: 'Créer la publication',
+      // createFolder: 'Créer la publication ici',
+      createResource: 'Créer le fichier ici', // Défaut : Créer la publication ici
+      // replaceFolder: 'Écraser ce dossier',
+      replaceResource: 'Remplacer le fichier' // Défaut : Écraser cette ressource
+    },
+    stepTitles: {
+      // createFolder: 'Sélection du dossier de destination',
+      // createResource: 'Sélection du dossier de destination',
+      // replaceFolder: 'Sélection du dossier à écraser',
+      replaceResource: 'Sélection du fichier à remplacer' // Défaut : Sélection de la ressource à écraser
+    }
+  }
+}
+
+export default i18n

package/lib/imports.ts

@@ -0,0 +1,136 @@
+import type { CatalogPlugin, GetResourceContext } from '@data-fair/types-catalogs'
+import type { OneGeoSuiteConfig, Link } from '#types'
+
+import axios from '@data-fair/lib-node/axios.js'
+
+export const getResource = async ({ catalogConfig, importConfig, resourceId, tmpDir, log }: GetResourceContext<OneGeoSuiteConfig>): ReturnType<CatalogPlugin['getResource']> => {
+  const format: string = importConfig.format
+  const service: string = importConfig.service
+  const catalog = (await axios.get(new URL(`fr/indexer/elastic/_search/?q=_id:${resourceId}`, catalogConfig.url).href)).data.hits.hits[0]
+
+  if (!catalog) {
+    throw Error(`resource ${service} not found for ${resourceId} in ${catalogConfig.url}`)
+  }
+
+  // filter links by format and service
+  const source: Link = catalog._source['metadata-fr'].link.find((x: Link) => {
+    return x.service === service || x.url === service
+  })
+
+  // table of format for make AFS url
+  const afsTable: Record<string, string> = {
+    CSV: 'text/csv',
+    JSON: 'application/json',
+    GeoJSON: 'application/Geo%2Bjson',
+    GML: 'application/gml%2Bxml',
+    KML: 'application/vnd.google-earth.kml%2Bxml',
+  }
+  // table of format for make WFS url
+  const wfsTable: Record<string, string> = {
+    CSV: 'csv',
+    GeoJSON: 'application/json',
+    'Shapefile (zip)': 'SHAPE-ZIP',
+    GML: 'GML3',
+    KML: 'kml',
+  }
+  // table of format
+  const extensionTable: Record<string, string> = {
+    CSV: '.csv',
+    GeoJSON: '.geojson',
+    JSON: '.json',
+    'Shapefile (zip)': '.zip',
+    ZIP: '.zip',
+    GML: '.gml',
+    KML: '.kml',
+    XML: '.xml',
+    ODS: '.ods',
+    'Excel non structuré': '.xlsx',
+    'Microsoft Excel': '.xls',
+  }
+
+  let downloadUrl: string
+  if (source.service === 'WS') {
+    downloadUrl = `${source.url}/${source.name}/all${extensionTable[format]}`
+  } else if (source.service === undefined) {
+    downloadUrl = `${source.url}`
+  } else if (source.service === 'AFS') {
+    downloadUrl = `${source.url}${source.name}/items?&crs=${source.projections![0]}&f=${afsTable[format]}&sortby=gid`
+  } else if (source.service === 'WFS') {
+    downloadUrl = `${source.url}?SERVICE=WFS&VERSION=2.0.0&request=GetFeature&typename=${source.name}&outputFormat=${wfsTable[format]}&startIndex=0&sortby=gid`
+  } else {
+    downloadUrl = `${source.url}`
+  }
+
+  await log.step(`Downloading the file ${downloadUrl}`)
+
+  // Download the resource
+  const fs = await import('node:fs')
+  const path = await import('path')
+
+  const axiosPortail = axios.create({
+    validateStatus: function (status) {
+      return status >= 200 && status < 500
+    }
+  })
+
+  let portail
+  if ([200].includes((await axiosPortail.get(new URL('explorer/fr', catalogConfig.url).href)).status)) {
+    portail = 'explorer/fr'
+  } else if ([200].includes((await axiosPortail.get(new URL('portail/fr', catalogConfig.url).href)).status)) {
+    portail = 'portail/fr'
+  }
+  const origin = portail ? `${catalogConfig.url}/${portail}/jeux-de-donnees/${catalog._source.slug}/info` : ''
+
+  let response
+  try {
+    response = await axios.get(downloadUrl, {
+      responseType: 'stream',
+    })
+    if (response.headers['content-type'] === 'text/html') {
+      response = undefined
+      throw Error('return HTML page')
+    }
+
+    await log.info(`Get file with ${downloadUrl} successfully! ${response.status}`)
+  } catch (e) {
+    await log.warning(`Get file fail with this url: ${downloadUrl}; ${e}`)
+  }
+
+  if (!response) {
+    throw Error(`Download failed ${origin}`)
+  }
+
+  // Create a filename
+  const fileName = catalog._source.slug + extensionTable[format]
+  const filePath = path.join(tmpDir, fileName)
+  await log.info(`Downloading resource to ${fileName}`)
+
+  // Create write stream
+  const writeStream = fs.createWriteStream(filePath)
+  response.data.pipe(writeStream)
+
+  // Return a promise that resolves with the file path
+  await new Promise((resolve, reject) => {
+    writeStream.on('finish', () => resolve(filePath))
+    writeStream.on('error', (error) => reject(error))
+  })
+  await log.info(`Resource ${fileName} downloaded successfully!`)
+
+  return {
+    id: resourceId,
+    slug: catalog._source.slug,
+    title: catalog._source['metadata-fr'].title,
+    description: source.description ?? catalog._source['metadata-fr'].abstratc,
+    filePath,
+    format,
+    frequency: catalog._source['metadata-fr'].updateFrequency ?? '',
+    license: {
+      href: '',
+      title: catalog._source['metadata-fr'].license
+    },
+    keywords: catalog._source['metadata-fr'].keyword,
+    updatedAt: catalog._source['metadata-fr'].lastUpdateDate ?? undefined,
+    image: catalog._source['metadata-fr'].image.find((x: { type: string, url: string | null }) => { return x.type === 'thumbnail' && !!x.url }),
+    origin
+  }
+}

package/lib/list.ts

@@ -0,0 +1,105 @@
+import type { CatalogPlugin, ListContext } from '@data-fair/types-catalogs'
+import type { OneGeoSuiteConfig, Link } from '#types'
+import type { OneGeoCapabilities } from './capabilities.ts'
+import axios from '@data-fair/lib-node/axios.js'
+
+type ResourceList = Awaited<ReturnType<CatalogPlugin['list']>>['results']
+
+const apiList: Array<string | undefined> = ['WS', 'AFS', 'WFS', undefined]
+const formatsList = [
+  'CSV', 'ODS', 'Excel non structuré', 'Microsoft Excel',
+  'ZIP', 'Shapefile (zip)', 'GeoJSON', 'JSON', 'XML', 'GML', 'KML']
+
+const getBestFormat = (formats: string[]) => {
+  return [...formats].sort((a, b) =>
+    (formatsList.indexOf(a) === -1 ? formatsList.length : formatsList.indexOf(a)) -
+    (formatsList.indexOf(b) === -1 ? formatsList.length : formatsList.indexOf(b))
+  )
+}
+const baseReqDataset = (input: string = '*', size: number = 100000, from: number = 1) => {
+  return {
+    from: (from - 1) * size,
+    size: Math.min(size, 10000),
+    track_total_hits: true,
+    query: {
+      bool: {
+        must: [{
+          bool: {
+            should: [{
+              query_string: {
+                query: input,
+                fields: ['data_and_metadata', 'metadata-fr.title^5', 'metadata-fr.abstract^3', 'content-fr.title^5', 'content-fr.excerpt^3', 'content-fr.plaintext'],
+                analyzer: 'my_search_analyzer',
+                fuzziness: 'AUTO',
+                minimum_should_match: '90%',
+                default_operator: 'AND',
+                boost: 5
+              }
+            }]
+          }
+        }, { term: { is_metadata: true } }, {
+          bool: {
+            should: [
+              ...apiList.filter((x: any) => { return x }).map((x: any) => { return { term: { 'metadata-fr.link.service.keyword': x } } }),
+              ...formatsList.filter((x: any) => { return x }).map((x: any) => { return { term: { 'metadata-fr.link.formats.keyword': x } } })],
+          }
+        }],
+        must_not: [{ term: { 'content-fr.status.keyword': 'draft' } }]
+      }
+    },
+    _source: { exclude: ['_dataset'] },
+    collapse: {
+      field: 'uuid.keyword'
+    },
+    post_filter: { terms: { 'type.keyword': ['dataset', 'nonGeographicDataset'] } }
+  }
+}
+
+export const list = async ({ catalogConfig, params }: ListContext<OneGeoSuiteConfig, OneGeoCapabilities>): ReturnType<CatalogPlugin['list']> => {
+  const url = catalogConfig.url
+  const listResources = async (params: Record<any, any>) => {
+    const catalogs = (await axios.post(new URL('fr/indexer/elastic/_search/', url).href, baseReqDataset(params.q, params.size, params.page))).data.hits.hits
+    const res = []
+
+    for (const catalog of catalogs) {
+      const sources: Array<Link> = catalog._source['metadata-fr'].link
+
+      // sort source by priority (services / format)
+      sources.sort((x: Link, y: Link) => {
+        const bestFormatX = formatsList.indexOf(getBestFormat(x.formats)[0]) === -1 ? formatsList.length : formatsList.indexOf(getBestFormat(x.formats)[0])
+        const bestFormatY = formatsList.indexOf(getBestFormat(y.formats)[0]) === -1 ? formatsList.length : formatsList.indexOf(getBestFormat(y.formats)[0])
+
+        if (bestFormatX !== bestFormatY) {
+          return bestFormatX - bestFormatY
+        }
+
+        return apiList.indexOf(x.service) - apiList.indexOf(y.service)
+      })
+
+      const formats: Array<string> = sources[0].formats
+      formats.sort((a: string, b: string) => {
+        return (formatsList.indexOf(a) === -1 ? formats.length : formatsList.indexOf(a)) - (formatsList.indexOf(b) === -1 ? formats.length : formatsList.indexOf(b))
+      })
+
+      let title = catalog._source['metadata-fr'].title
+      if (sources[0].service) title += ` - ( ${sources[0].service} )`
+
+      res.push({
+        id: `${catalog._id}`,
+        title,
+        description: sources[0].description,
+        format: formats[0],
+        type: 'resource'
+      } as ResourceList[number])
+    }
+    return res
+  }
+  // List datasets
+  const resources = await listResources(params)
+
+  return {
+    count: resources.length,
+    results: resources,
+    path: []
+  }
+}

package/lib/prepare.ts

@@ -0,0 +1,21 @@
+import type { OneGeoSuiteConfig } from '#types'
+import type { OneGeoCapabilities } from './capabilities.ts'
+import type { PrepareContext } from '@data-fair/types-catalogs'
+import axios from '@data-fair/lib-node/axios.js'
+
+export default async ({ catalogConfig }: PrepareContext<OneGeoSuiteConfig, OneGeoCapabilities>) => {
+  if (!catalogConfig.url) {
+    throw new Error('Catalog configuration is missing the "url" property.')
+  }
+
+  try {
+    await axios.get(`${catalogConfig.url}/fr/dataset`)
+  } catch (error) {
+    console.error(`Error connecting to OneGeoSuite API at ${catalogConfig.url}:`, error)
+    throw new Error(`Unable to connect to OneGeoSuite API at ${catalogConfig.url}. Please check the URL and your network connection.`)
+  }
+
+  return {
+    catalogConfig
+  }
+}

package/lib/resources/thumbnail.svg

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg version="1.1" xmlns="http://www.w3.org/2000/svg" width="512" height="512">
+<path d="M0 0 C0.79647949 0.38526855 1.59295898 0.77053711 2.41357422 1.16748047 C24.81002753 12.13055578 43.9816398 26.88788868 62 44 C62.82757813 44.78503906 63.65515625 45.57007812 64.5078125 46.37890625 C106.9685617 87.73005399 130.23101425 148.42030708 131.28540039 207.05566406 C131.59882474 248.33732105 121.93795584 286.42876284 103 323 C102.62875 323.71897461 102.2575 324.43794922 101.875 325.17871094 C74.12278653 378.10846963 23.08672214 417.49108893 -33.35644531 435.43798828 C-93.69706641 453.85207444 -159.00775803 448.49453111 -215.05615234 418.93432617 C-235.27046624 407.87020872 -253.40007319 393.92306944 -270 378 C-271.23556641 376.82630859 -271.23556641 376.82630859 -272.49609375 375.62890625 C-315.0977993 334.20853049 -338.2119083 273.24624342 -339.35351562 214.52685547 C-339.60381785 173.43747055 -329.84205873 135.38604949 -311 99 C-310.62875 98.28102539 -310.2575 97.56205078 -309.875 96.82128906 C-295.86947514 70.10958003 -274.60942399 45.6175378 -251 27 C-249.989375 26.18402344 -248.97875 25.36804688 -247.9375 24.52734375 C-240.05155229 18.22762182 -231.81768276 12.90041285 -223 8 C-222.16178711 7.53303711 -221.32357422 7.06607422 -220.45996094 6.58496094 C-199.17553041 -5.15474472 -177.68298678 -13.54321825 -154 -19 C-153.2997168 -19.16725586 -152.59943359 -19.33451172 -151.87792969 -19.50683594 C-101.16004552 -31.52100615 -46.35553466 -22.54256947 0 0 Z " fill="#FEFEFE" transform="translate(360,45)"/>
+<path d="M0 0 C19.8281058 16.94753396 32.62414399 39.80974347 39.40625 64.8359375 C39.61338623 65.59156982 39.82052246 66.34720215 40.03393555 67.12573242 C42.97489852 78.58346637 42.7350267 90.28871548 42.70727539 102.03198242 C42.70699282 103.71831256 42.70715262 105.40464283 42.7077179 107.0909729 C42.70800313 111.63770811 42.70215085 116.18441659 42.69514394 120.73114562 C42.68886464 125.49437176 42.68830299 130.25759861 42.68711853 135.02082825 C42.68401866 144.02674827 42.67582347 153.03265605 42.66576904 162.0385707 C42.65456605 172.29739556 42.64908693 182.55622102 42.64407361 192.81505048 C42.63363966 213.90535449 42.61531099 234.99564173 42.59375 256.0859375 C19.82375 256.0859375 -2.94625 256.0859375 -26.40625 256.0859375 C-26.4155957 251.00944824 -26.42494141 245.93295898 -26.43457031 240.70263672 C-26.46837743 223.90687266 -26.52374779 207.11123041 -26.59015274 190.31556511 C-26.62987961 180.13501615 -26.66230429 169.95454378 -26.67724609 159.77392578 C-26.69029562 150.8954554 -26.71734414 142.017154 -26.76086307 133.13877881 C-26.78340388 128.44229128 -26.79916513 123.74601159 -26.79813385 119.04946518 C-26.79738285 114.61868132 -26.81550843 110.18835561 -26.84741783 105.75769043 C-26.85585779 104.14135965 -26.85770745 102.52497711 -26.85205269 100.90863419 C-26.80557209 85.56564536 -29.66093065 73.01043601 -38.40625 60.0859375 C-38.84453125 59.43109375 -39.2828125 58.77625 -39.734375 58.1015625 C-47.6490066 47.70764871 -61.75610835 40.37594635 -74.40625 38.0859375 C-92.61294321 36.39217116 -107.56580766 38.80249007 -122.40625 50.0859375 C-133.83917181 59.599906 -141.46757143 73.37212762 -143.40625 88.0859375 C-143.70437324 93.6050686 -143.71794879 99.11787391 -143.72509766 104.64306641 C-143.73441034 106.29969769 -143.74458098 107.95632434 -143.75553894 109.61294556 C-143.78270198 114.08327541 -143.79794747 118.55357399 -143.81096697 123.02396441 C-143.8266578 127.70582167 -143.85342888 132.38761563 -143.8789978 137.06942749 C-143.9256806 145.92306236 -143.96247536 154.77670928 -143.99567068 163.63040388 C-144.03396647 173.71512644 -144.08335699 183.79978528 -144.13365483 193.88445401 C-144.23681846 214.61824052 -144.32466493 235.35205408 -144.40625 256.0859375 C-166.84625 256.0859375 -189.28625 256.0859375 -212.40625 256.0859375 C-212.40625 163.6859375 -212.40625 71.2859375 -212.40625 -23.9140625 C-189.96625 -23.9140625 -167.52625 -23.9140625 -144.40625 -23.9140625 C-144.40625 -21.9340625 -144.40625 -19.9540625 -144.40625 -17.9140625 C-143.29830078 -18.49414062 -143.29830078 -18.49414062 -142.16796875 -19.0859375 C-94.80898774 -43.39728226 -39.86540793 -33.54788588 0 0 Z " fill="#313C4E" transform="translate(339.40625,139.9140625)"/>
+</svg>

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@data-fair/catalog-onegeo-suite",
+  "description": "OneGeoSuite plugin for the Data Fair catalogs service.",
+  "version": "0.1.0",
+  "main": "index.ts",
+  "type": "module",
+  "scripts": {
+    "build-types": "df-build-types ./",
+    "check-types": "tsc",
+    "lint": "eslint .",
+    "prepare": "husky || true",
+    "test-base": "cross-env NODE_ENV=test EVENTS_LOG_LEVEL=alert node --disable-warning=ExperimentalWarning --test-force-exit --test-concurrency=1 --test",
+    "test-only": "npm run test-base -- --test-only test-it/*.ts",
+    "test": "npm run test-base test-it/*.ts",
+    "quality": "npm run lint && npm run build-types && npm run check-types && npm run test && npm audit --omit=dev --audit-level=critical",
+    "prepublishOnly": "npm run build-types"
+  },
+  "files": [
+    "./lib/**",
+    "./types/**",
+    "index.ts"
+  ],
+  "imports": {
+    "#types": "./types/index.ts",
+    "#type/*": "./types/*"
+  },
+  "keywords": [
+    "data-fair-catalogs-plugin"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@data-fair/lib-node": "^2.11.0",
+    "@data-fair/lib-validation": "^1.0.2",
+    "prom-client": "^15.1.3"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.0",
+    "@commitlint/config-conventional": "^19.8.0",
+    "@data-fair/lib-types-builder": "^1.8.0",
+    "@data-fair/types-catalogs": "^0.6.0",
+    "@types/fs-extra": "^11.0.4",
+    "chalk": "^5.4.1",
+    "cross-env": "^10.1.0",
+    "dayjs": "^1.11.13",
+    "draftlog": "^1.0.13",
+    "eslint": "^9.25.1",
+    "fs-extra": "^11.3.0",
+    "husky": "^9.1.7",
+    "neostandard": "^0.12.1",
+    "typescript": "^5.8.3"
+  },
+  "relativeDependencies": {
+    "@data-fair/types-catalogs": "../../catalogs/types-catalogs"
+  }
+}

package/types/catalogConfig/.type/index.d.ts

@@ -0,0 +1,20 @@
+
+export const schemaExports: string[]
+
+// see https://github.com/bcherny/json-schema-to-typescript/issues/439 if some types are not exported
+/**
+ * The url of the catalog
+ */
+export type URL = string;
+
+export type OneGeoSuiteConfig = {
+  url: URL;
+}
+
+
+export declare function validate(data: any): data is OneGeoSuiteConfig
+export declare function assertValid(data: any, options?: import('@data-fair/lib-validation').AssertValidOptions): asserts data is OneGeoSuiteConfig
+export declare function returnValid(data: any, options?: import('@data-fair/lib-validation').AssertValidOptions): OneGeoSuiteConfig
+      
+export declare const schema: any
+        

package/types/catalogConfig/.type/index.js

@@ -0,0 +1,53 @@
+/* eslint-disable */
+
+
+import validate from './validate.js'
+import { assertValid as assertValidGeneric } from '@data-fair/lib-validation'
+
+export const schemaExports = [
+  "types",
+  "validate",
+  "schema"
+]
+
+export { validate } from './validate.js'
+export function assertValid(data, options) {
+  assertValidGeneric(validate, data, options)
+}
+export function returnValid(data, options) {
+  assertValid(data, options)
+  return data
+}
+
+export const schema = {
+  "$id": "https://github.com/data-fair/catalog-onegeo-suite/catalog-config",
+  "x-exports": [
+    "types",
+    "validate",
+    "schema"
+  ],
+  "title": "OneGeoSuiteConfig",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "url"
+  ],
+  "properties": {
+    "url": {
+      "type": "string",
+      "title": "URL",
+      "description": "The url of the catalog",
+      "x-i18n-description": {
+        "fr": "L'URL du catalogue"
+      },
+      "pattern": "^https?://.*[^/]$",
+      "errorMessage": "The URL must start with http:// or https:// and must not end with `/`.",
+      "x-i18n-errorMessage": {
+        "fr": "L'URL doit commencer par http:// ou https:// et ne pas se terminer par `/`."
+      },
+      "examples": [
+        "https://demo.onegeosuite.fr"
+      ]
+    }
+  }
+}

package/types/catalogConfig/.type/validate.js

@@ -0,0 +1,102 @@
+/* eslint-disable */
+// @ts-nocheck
+
+"use strict";
+export const validate = validate14;
+export default validate14;
+const schema16 = {"$id":"https://github.com/data-fair/catalog-onegeo-suite/catalog-config","x-exports":["types","validate","schema"],"title":"OneGeoSuiteConfig","type":"object","additionalProperties":false,"required":["url"],"properties":{"url":{"type":"string","title":"URL","description":"The url of the catalog","x-i18n-description":{"fr":"L'URL du catalogue"},"pattern":"^https?://.*[^/]$","errorMessage":"The URL must start with http:// or https:// and must not end with `/`.","x-i18n-errorMessage":{"fr":"L'URL doit commencer par http:// ou https:// et ne pas se terminer par `/`."},"examples":["https://demo.onegeosuite.fr"]}}};
+const pattern0 = new RegExp("^https?://.*[^/]$", "u");
+
+function validate14(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){
+/*# sourceURL="https://github.com/data-fair/catalog-onegeo-suite/catalog-config" */;
+let vErrors = null;
+let errors = 0;
+if(data && typeof data == "object" && !Array.isArray(data)){
+if(data.url === undefined){
+const err0 = {instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: "url"},message:"must have required property '"+"url"+"'"};
+if(vErrors === null){
+vErrors = [err0];
+}
+else {
+vErrors.push(err0);
+}
+errors++;
+}
+for(const key0 in data){
+if(!(key0 === "url")){
+const err1 = {instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"};
+if(vErrors === null){
+vErrors = [err1];
+}
+else {
+vErrors.push(err1);
+}
+errors++;
+}
+}
+if(data.url !== undefined){
+let data0 = data.url;
+if(typeof data0 === "string"){
+if(!pattern0.test(data0)){
+const err2 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/pattern",keyword:"pattern",params:{pattern: "^https?://.*[^/]$"},message:"must match pattern \""+"^https?://.*[^/]$"+"\""};
+if(vErrors === null){
+vErrors = [err2];
+}
+else {
+vErrors.push(err2);
+}
+errors++;
+}
+}
+else {
+const err3 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/type",keyword:"type",params:{type: "string"},message:"must be string"};
+if(vErrors === null){
+vErrors = [err3];
+}
+else {
+vErrors.push(err3);
+}
+errors++;
+}
+if(errors > 0){
+const emErrs0 = [];
+for(const err4 of vErrors){
+if(((((err4.keyword !== "errorMessage") && (!err4.emUsed)) && ((err4.instancePath === instancePath+"/url") || ((err4.instancePath.indexOf(instancePath+"/url") === 0) && (err4.instancePath[instancePath+"/url".length] === "/")))) && (err4.schemaPath.indexOf("#/properties/url") === 0)) && (err4.schemaPath["#/properties/url".length] === "/")){
+emErrs0.push(err4);
+err4.emUsed = true;
+}
+}
+if(emErrs0.length){
+const err5 = {instancePath:instancePath+"/url",schemaPath:"#/properties/url/errorMessage",keyword:"errorMessage",params:{errors: emErrs0},message:"The URL must start with http:// or https:// and must not end with `/`."};
+if(vErrors === null){
+vErrors = [err5];
+}
+else {
+vErrors.push(err5);
+}
+errors++;
+}
+const emErrs1 = [];
+for(const err6 of vErrors){
+if(!err6.emUsed){
+emErrs1.push(err6);
+}
+}
+vErrors = emErrs1;
+errors = emErrs1.length;
+}
+}
+}
+else {
+const err7 = {instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"};
+if(vErrors === null){
+vErrors = [err7];
+}
+else {
+vErrors.push(err7);
+}
+errors++;
+}
+validate14.errors = vErrors;
+return errors === 0;
+}

package/types/catalogConfig/index.ts

@@ -0,0 +1 @@
+export * from './.type/index.js'

package/types/catalogConfig/schema.json

@@ -0,0 +1,32 @@
+{
+  "$id": "https://github.com/data-fair/catalog-onegeo-suite/catalog-config",
+  "x-exports": [
+    "types",
+    "validate",
+    "schema"
+  ],
+  "title": "OneGeoSuiteConfig",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "url"
+  ],
+  "properties": {
+    "url": {
+      "type": "string",
+      "title": "URL",
+      "description": "The url of the catalog",
+      "x-i18n-description": {
+        "fr": "L'URL du catalogue"
+      },
+      "pattern": "^https?://.*[^/]$",
+      "errorMessage": "The URL must start with http:// or https:// and must not end with `/`.",
+      "x-i18n-errorMessage": {
+        "fr": "L'URL doit commencer par http:// ou https:// et ne pas se terminer par `/`."
+      },
+      "examples": [
+        "https://demo.onegeosuite.fr"
+      ]
+    }
+  }
+}

package/types/importConfig/.type/index.d.ts

@@ -0,0 +1,5 @@
+
+export const schemaExports: string[]
+
+export declare const schema: any
+        

package/types/importConfig/.type/index.js

@@ -0,0 +1,84 @@
+/* eslint-disable */
+
+
+
+export const schemaExports = [
+  "schema"
+]
+
+export const schema = {
+  "$id": "https://github.com/data-fair/catalog-onegeo-suite/import-config",
+  "x-exports": [
+    "schema"
+  ],
+  "title": "ImportConfig",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "service",
+    "format"
+  ],
+  "properties": {
+    "service": {
+      "type": "string",
+      "title": "Web Service",
+      "description": "The source of the resource",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "image_url": {
+          "type": "string"
+        }
+      },
+      "layout": {
+        "getItems": {
+          "url": "${context.catalogConfig.url}/fr/indexer/elastic/_search/?q=_id:${context.resourceId}",
+          "itemsResults": "(function() { const links = data.hits.hits[0]._source['metadata-fr'].link; return links.filter(l => l.formats.find(f => ['CSV', 'ODS', 'Excel non structuré', 'Microsoft Excel','ZIP', 'Shapefile (zip)', 'GeoJSON', 'JSON', 'XML', 'GML', 'KML'].includes(f)) || ['WS', 'AFS', 'WFS'].includes(l.service)).map((l, i) =>  [l, i] );  })()",
+          "itemTitle": "item[0].service?? 'Local N°' + (item[1] + 1)",
+          "itemValue": "item[0].service??  item[0].url"
+        }
+      }
+    },
+    "format": {
+      "type": "string",
+      "title": "Format",
+      "description": "the fomat use",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "image_url": {
+          "type": "string"
+        }
+      },
+      "layout": {
+        "getItems": {
+          "url": "${context.catalogConfig.url}/fr/indexer/elastic/_search/?q=_id:${context.resourceId}",
+          "itemsResults": "(function(){return data.hits.hits[0]._source['metadata-fr'].link.find(x => x.service === parent.data.service || x.url === parent.data.service).formats; })()",
+          "itemTitle": "item",
+          "itemValue": "item"
+        }
+      }
+    }
+  },
+  "layout": [
+    {
+      "children": [
+        "service"
+      ]
+    },
+    {
+      "if": "parent.data.service != null",
+      "children": [
+        "format"
+      ]
+    }
+  ]
+}

package/types/importConfig/index.ts

@@ -0,0 +1 @@
+export * from './.type/index.js'

package/types/importConfig/schema.json

@@ -0,0 +1,76 @@
+{
+  "$id": "https://github.com/data-fair/catalog-onegeo-suite/import-config",
+  "x-exports": [
+    "schema"
+  ],
+  "title": "ImportConfig",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "service",
+    "format"
+  ],
+  "properties": {
+    "service": {
+      "type": "string",
+      "title": "Web Service",
+      "description": "The source of the resource",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "image_url": {
+          "type": "string"
+        }
+      },
+      "layout": {
+        "getItems": {
+          "url": "${context.catalogConfig.url}/fr/indexer/elastic/_search/?q=_id:${context.resourceId}",
+          "itemsResults": "(function() { const links = data.hits.hits[0]._source['metadata-fr'].link; return links.filter(l => l.formats.find(f => ['CSV', 'ODS', 'Excel non structuré', 'Microsoft Excel','ZIP', 'Shapefile (zip)', 'GeoJSON', 'JSON', 'XML', 'GML', 'KML'].includes(f)) || ['WS', 'AFS', 'WFS'].includes(l.service)).map((l, i) =>  [l, i] );  })()",
+          "itemTitle": "item[0].service?? 'Local N°' + (item[1] + 1)",
+          "itemValue": "item[0].service??  item[0].url"
+        }
+      }
+    },
+    "format": {
+      "type": "string",
+      "title": "Format",
+      "description": "the fomat use",
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "image_url": {
+          "type": "string"
+        }
+      },
+      "layout": {
+        "getItems": {
+          "url": "${context.catalogConfig.url}/fr/indexer/elastic/_search/?q=_id:${context.resourceId}",
+          "itemsResults": "(function(){return data.hits.hits[0]._source['metadata-fr'].link.find(x => x.service === parent.data.service || x.url === parent.data.service).formats; })()",
+          "itemTitle": "item",
+          "itemValue": "item"
+        }
+      }
+    }
+  },
+  "layout": [
+    {
+      "children": [
+        "service"
+      ]
+    },
+    {
+      "if": "parent.data.service != null",
+      "children": [
+        "format"
+      ]
+    }
+  ]
+}

package/types/index.ts

@@ -0,0 +1,12 @@
+export { schema as configSchema, assertValid as assertConfigValid, type OneGeoSuiteConfig } from './catalogConfig/index.ts'
+export { schema as importConfigSchema } from './importConfig/index.ts'
+
+export type Link = {
+  _main: boolean,
+  name: string,
+  description?: string,
+  formats: string[],
+  service?: string,
+  url: string,
+  projections?: string[]
+}