@data-fair/catalog-data-fair 0.1.0

package/README.md

@@ -0,0 +1,4 @@
+# <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-mock
+
+A simple mock plugin for the Data Fair catalogs service.
+This plugin can be used as a template for creating new plugins.

package/index.ts

@@ -0,0 +1,36 @@
+import type CatalogPlugin from '@data-fair/types-catalogs'
+import { importConfigSchema, configSchema, assertConfigValid, type DataFairConfig } from '#types'
+import { type DataFairCapabilities, capabilities } from './lib/capabilities.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<DataFairConfig, DataFairCapabilities> = {
+  async prepare (context) {
+    const prepare = (await import('./lib/prepare.ts')).default
+    return prepare(context)
+  },
+
+  async listResources (context) {
+    const { listResources } = await import('./lib/imports.ts')
+    return listResources(context)
+  },
+
+  async getResource (context) {
+    const { getResource } = await import('./lib/download.ts')
+    return getResource(context)
+  },
+
+  metadata: {
+    title: 'Catalog Data Fair',
+    description: 'Data Fair plugin for Data Fair Catalog',
+    thumbnailPath: './lib/resources/thumbnail.svg',
+    capabilities
+  },
+
+  importConfigSchema,
+  configSchema,
+  assertConfigValid
+}
+export default plugin

package/lib/capabilities.ts

@@ -0,0 +1,18 @@
+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.
+ * We add "as const" to ensure the type is a list of literal type, not a list of strings.
+ * This allows TypeScript to check if the plugin has the required funcitons for each capability.
+ */
+export const capabilities = [
+  'import',
+  'search',
+  'pagination',
+  'importConfig',
+  'thumbnail',
+] satisfies Capability[]
+
+export type DataFairCapabilities = typeof capabilities
+export default capabilities

package/lib/download.ts

@@ -0,0 +1,226 @@
+import type { DataFairConfig, DataFairDataset, ImportConfig } from '#types'
+import type { CatalogPlugin, GetResourceContext, Resource } from '@data-fair/types-catalogs'
+import axios from '@data-fair/lib-node/axios.js'
+import * as fs from 'fs'
+import { join } from 'path'
+import { Transform } from 'stream'
+
+/**
+ * Retrieves a resource by first fetching its metadata and then downloading the actual resource.
+ * The downloaded file path is added to the dataset metadata before returning.
+ *
+ * @param context - The context containing configuration and parameters required to fetch and download the resource.
+ * @returns A promise that resolves to the dataset metadata with the downloaded file path included.
+ */
+export const getResource = async (context: GetResourceContext<DataFairConfig>): ReturnType<CatalogPlugin['getResource']> => {
+  context.log.step('Import de la ressource')
+
+  const resource = await getMetaData(context)
+  resource.filePath = await downloadResource(context, resource)
+
+  return resource
+}
+
+/**
+ * Returns the DataFair Resource with all its metadatas
+ * @param catalogConfig the DataFair configuration [ex: { url: 'https://example.com' }]
+ * @param resourceId the dataset Id to fetch fields from
+ * @returns the Resource corresponding to the id by this configuration
+ */
+const getMetaData = async ({ catalogConfig, resourceId, log }: GetResourceContext<DataFairConfig>): Promise<Resource> => {
+  let dataset: DataFairDataset
+  try {
+    const url = `${catalogConfig.url}/data-fair/api/v1/datasets/${resourceId}`
+    const res = (await axios.get(url))
+    if (res.status !== 200) {
+      throw new Error(`HTTP error : ${res.status}, ${res.data}`)
+    }
+    dataset = res.data
+    log.info('Import des métadonnées de la ressource', { url })
+  } catch (e) {
+    console.error('Error while fetching metadatas', e)
+    throw new Error(`Erreur lors de la récuperation de la resource DataFair. ${e instanceof Error ? e.message : e}`)
+  }
+
+  const resource: Resource = {
+    id: resourceId,
+    title: dataset.title,
+    description: dataset.description,
+    format: 'csv',
+    origin: `${catalogConfig.url}/datasets/${resourceId}`,
+    frequency: dataset.frequency,
+    image: dataset.image,
+    keywords: dataset.keywords,
+    size: dataset.file?.size,
+    schema: dataset.schema,
+    filePath: '',
+  }
+
+  if (dataset.license) {
+    resource.license = {
+      title: dataset.license.title ?? '',
+      href: dataset.license.href ?? '',
+    }
+  }
+  return resource
+}
+
+/**
+ * Download a specified from a Data Fair service.
+ * If the resource has a distant file and no import configuration will download the distant file, otherwise the data will be fetch by set of rows.
+ * @param context - the download context, contains the download configuration, the resource Id
+ * @param res - the metadatas about the resource.
+ * @returns A promise resolving to the file path of the downloaded CSV.
+ */
+const downloadResource = async (context: GetResourceContext<DataFairConfig>, res: Resource): Promise<string> => {
+  const filePath = join(context.tmpDir, `${context.resourceId}.csv`)
+  try {
+    if (res.size && res.size > 0 && context.importConfig.fields?.length === 0 && context.importConfig.filters?.length === 0) {
+      await downloadResourceFile(filePath, context)
+    } else {
+      await downloadResourceLines(filePath, context)
+    }
+    return filePath
+  } catch (error) {
+    console.error('Error while downloading the file', error)
+    context.log.error(`Erreur pendant le téléchargement du fichier : ${error instanceof Error ? error.message : error}`)
+    throw new Error(`Erreur pendant le téléchargement du fichier: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}
+
+/**
+ * Downloads the rows of a dataset thanks to its full file and saves them as a CSV file in a given file path. The configuration  of the importConfig is not applicable.
+ * @param filePath - The path to the temporary file where the CSV will be saved.
+ * @param catalogConfig - The DataFair configuration object.
+ * @param resourceId - The Id of the dataset to download.
+ * @param log - The log utilitary to display messages
+ * @returns A promise that resolves when the file is successfully downloaded and saved.
+ * @throws If there is an error writing the file or fetching the dataset.
+ */
+const downloadResourceFile = async (filePath: string, { catalogConfig, resourceId, log }: GetResourceContext<DataFairConfig>): Promise<void> => {
+  const url = `${catalogConfig.url}/data-fair/api/v1/datasets/${resourceId}/full`
+  log.info('Import des données de la ressource', url)
+
+  const fileStream = fs.createWriteStream(filePath)
+
+  const response = await axios.get(url, { responseType: 'stream' })
+
+  if (response.status !== 200) {
+    throw new Error(`Error while fetching data: HTTP ${response.statusText}`)
+  }
+
+  return new Promise<void>((resolve, reject) => {
+    response.data.pipe(fileStream)
+    fileStream.on('finish', () => {
+      resolve()
+    })
+    response.data.on('error', (err: any) => {
+      fs.unlink(filePath, () => { }) // Delete the file in case of error
+      reject(err)
+    })
+    fileStream.on('error', (err) => {
+      fs.unlink(filePath, () => { }) // Delete the file in case of error
+      reject(err)
+    })
+  })
+}
+
+/**
+ * Downloads the rows of a dataset matching the given filters and saves them as a CSV file in a given file path.
+ * @param filePath - The path to the temporary file where the CSV will be saved.
+ * @param catalogConfig - The DataFair configuration object.
+ * @param resourceId - The Id of the dataset to download.
+ * @param importConfig - The import configuration, including filters to apply.
+ * @param log - The log utilitary to display messages
+ * @returns A promise that resolves when the file is successfully downloaded and saved.
+ * @throws If there is an error writing the file or fetching the dataset.
+ */
+const downloadResourceLines = async (destFile: string, { catalogConfig, resourceId, importConfig, log }: GetResourceContext<DataFairConfig> & { importConfig: ImportConfig }) => {
+  let url: string | null = `${catalogConfig.url}/data-fair/api/v1/datasets/${resourceId}/lines?format=csv&size=3000`
+
+  if (importConfig.fields) {
+    url += '&select=' + importConfig.fields.map(field => field.key).join(',')
+  }
+
+  if (importConfig.filters) {
+    importConfig.filters.forEach((filter) => {
+      switch (filter.type) {
+        case 'in':
+        case 'nin':
+          url += `&${filter.field.key}_${filter.type}="${filter.values?.join('","')}"`
+          break
+        case 'starts':
+        case 'gte':
+        case 'lte':
+          url += `&${filter.field.key}_${filter.type}=${filter.value}`
+          break
+        default:
+          break
+      }
+    })
+  }
+
+  log.info('Import des données de la ressource', url)
+  const writer = fs.createWriteStream(destFile)
+  let isFirstChunk = true
+
+  while (url) {
+    console.log(url)
+    const response = await axios.get(url, { responseType: 'stream' })
+    if (response.status !== 200) {
+      throw new Error(`Error while fetching data: HTTP ${response.statusText}`)
+    }
+
+    await new Promise<void>((resolve, reject) => {
+      let stream = response.data
+      if (!isFirstChunk) {
+        let skippedHeader = false
+        stream = response.data.pipe(new Transform({
+          transform (chunk, _encoding, callback) {
+            if (!skippedHeader) {
+              const headerEndIndex = chunk.indexOf('\n')
+              if (headerEndIndex !== -1) {
+                chunk = chunk.slice(headerEndIndex + 1)
+                skippedHeader = true
+              }
+            }
+            this.push(chunk)
+            callback()
+          }
+        }))
+      }
+      stream.pipe(writer, { end: false })
+      stream.on('end', () => {
+        const linkHeader = response.headers.link
+        url = extractNextPageUrl(linkHeader)
+        isFirstChunk = false
+        resolve()
+      })
+      stream.on('error', (error: any) => {
+        writer.close()
+        console.error(`Error while fetching lines at ${url}`, error)
+        reject(error)
+      })
+    })
+  }
+  writer.end()
+}
+
+/**
+ * Extract the next url (to fetch the next page) from the headers.
+ * @param linkHeader the header where the `next` url should be
+ * @returns the url if exists, null otherwise
+ */
+const extractNextPageUrl = (linkHeader: string | undefined): string | null => {
+  if (!linkHeader) return null
+  const links = linkHeader.split(',')
+  for (const link of links) {
+    const [urlPart, relPart] = link.split(';')
+    const url = urlPart.trim().slice(1, -1) // Remove < and >
+    const rel = relPart.trim()
+    if (rel === 'rel=next') {
+      return url
+    }
+  }
+  return null
+}

package/lib/imports.ts

@@ -0,0 +1,58 @@
+import type { DataFairCatalog, DataFairDataset, DataFairConfig } from '#types'
+import axios from '@data-fair/lib-node/axios.js'
+import type { CatalogPlugin, ListResourcesContext } from '@data-fair/types-catalogs'
+import type { DataFairCapabilities } from './capabilities.ts'
+
+type ResourceList = Awaited<ReturnType<CatalogPlugin['listResources']>>['results']
+
+/**
+ * Transform an ODS catalog into a Data Fair catalog
+ * @param dataFairDataset the dataset to transform
+ * @returns an object containing the count of resources, the transformed resources, and an empty path array
+ */
+const prepareCatalog = (dataFairDatasets: DataFairDataset[]): ResourceList => {
+  const catalog: ResourceList = []
+
+  for (const dataFairDataset of dataFairDatasets) {
+    catalog.push({
+      id: dataFairDataset.id,
+      title: dataFairDataset.title,
+      format: 'csv',
+      size: dataFairDataset.file?.size ?? dataFairDataset.storage?.size ?? dataFairDataset.originalFile?.size,
+      type: 'resource',
+    } as ResourceList[number])
+  }
+  return catalog
+}
+
+/**
+ * Returns the catalog [list of dataset] from a Data Fair service
+ * @param config the Data Fair configuration
+ * @returns the list of Resources available on this catalog
+ */
+export const listResources = async (config: ListResourcesContext<DataFairConfig, DataFairCapabilities>): ReturnType<CatalogPlugin<DataFairConfig>['listResources']> => {
+  const dataFairParams: Record<string, any> = {}
+  if (config.params?.q) dataFairParams.q = config.params.q
+  if (config.params?.size) dataFairParams.size = config.params.size
+  if (config.params?.page) dataFairParams.page = config.params.page
+
+  let data: DataFairCatalog
+  const url = `${config.catalogConfig.url}/data-fair/api/v1/catalog/datasets`
+  try {
+    const res = (await axios.get(url, { params: dataFairParams }))
+    if (res.status !== 200) {
+      throw new Error(`HTTP error : ${res.status}, ${res.data}`)
+    }
+    data = res.data
+  } catch (e) {
+    console.error(`Error fetching datasets from ${url} : ${e}`)
+    throw new Error(`Erreur lors de la récuperation de la resource Data Fair (${e instanceof Error ? e.message : ''})`)
+  }
+
+  const catalog = prepareCatalog(data.results)
+  return {
+    count: data.count,
+    results: catalog,
+    path: []
+  }
+}

package/lib/prepare.ts

@@ -0,0 +1,23 @@
+import type { PrepareContext } from '@data-fair/types-catalogs'
+import type { DataFairCapabilities } from './capabilities.ts'
+import type { DataFairConfig } from '#types'
+import axios from '@data-fair/lib-node/axios.js'
+
+export default async ({ catalogConfig, capabilities, secrets }: PrepareContext<DataFairConfig, DataFairCapabilities>) => {
+  // To remove when catalog/datasets allows q parameters
+  capabilities = capabilities.filter(c => c !== 'search')
+
+  // test the url
+  try {
+    await axios.get(catalogConfig.url + '/data-fair/api/v1/catalog/datasets?size=1&select=id')
+  } catch (e) {
+    console.error('Erreur URL pendant la configuration : ', e instanceof Error ? e.message : e)
+    throw new Error('Configuration invalide, vérifiez l\'URL')
+  }
+
+  return {
+    catalogConfig,
+    capabilities,
+    secrets
+  }
+}

package/lib/resources/thumbnail.svg

@@ -0,0 +1,19 @@
+<svg viewBox="-5 0 110 100" width="200" height="200" class="logo" version="1.1" xmlns="http://www.w3.org/2000/svg">
+  <defs>
+    <filter id="dropshadow">
+        <feGaussianBlur in="SourceAlpha" stdDeviation="2"/>
+        <feOffset dx="2" dy="2" result="offsetblur"/>
+        <feMerge>
+            <feMergeNode/>
+            <feMergeNode in="SourceGraphic"/>
+        </feMerge>
+    </filter>
+   </defs>
+    <g>
+        <!--<path d="M35,5 L65,5 L31,92 A4,4 0 0 1 28,95 L2,95 A3,3 0 0 1 1,92 Z" fill="#90caf9" filter="url(#dropshadow)"></path>
+        <path d="M65,5 L35,5 L69,92 A4,4 0 0 0 72,95 L98,95 A3,3 0 0 0 99,92 Z" fill="#0288d1" filter="url(#dropshadow)"></path>-->
+
+        <path d="M48,4 L71,52 L0,100 Z" fill="#0288d1" filter="url(#dropshadow)"/>
+        <path d="M50,0 L25,50 L100,100 Z" fill="#90caf9" filter="url(#dropshadow)"/>
+    </g>
+</svg>

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@data-fair/catalog-data-fair",
+  "description": "A simple Data Fair 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": "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.8.2",
+    "@data-fair/lib-utils": "^1.6.0",
+    "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.3.0",
+    "@types/nock": "^10.0.3",
+    "chalk": "^5.4.1",
+    "dayjs": "^1.11.13",
+    "draftlog": "^1.0.13",
+    "eslint": "^9.25.1",
+    "husky": "^9.1.7",
+    "neostandard": "^0.12.1",
+    "nock": "^14.0.5",
+    "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 DataFairConfig = {
+  url: URL;
+}
+
+
+export declare function validate(data: any): data is DataFairConfig
+export declare function assertValid(data: any, options?: import('@data-fair/lib-validation').AssertValidOptions): asserts data is DataFairConfig
+export declare function returnValid(data: any, options?: import('@data-fair/lib-validation').AssertValidOptions): DataFairConfig
+      
+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-data-fair/catalog-config",
+  "x-exports": [
+    "types",
+    "validate",
+    "schema"
+  ],
+  "title": "DataFairConfig",
+  "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 site où le catalogue est publié. *L'URL de l'API utilisée sera* *https*[]()*://example.com***/data-fair/api/v1**"
+      },
+      "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://example.com"
+      ]
+    }
+  }
+}

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-data-fair/catalog-config","x-exports":["types","validate","schema"],"title":"DataFairConfig","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 site où le catalogue est publié. *L'URL de l'API utilisée sera* *https*[]()*://example.com***/data-fair/api/v1**"},"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://example.com"]}}};
+const pattern0 = new RegExp("^https?://.*[^/]$", "u");
+
+function validate14(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){
+/*# sourceURL="https://github.com/data-fair/catalog-data-fair/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,30 @@
+{
+  "$id": "https://github.com/data-fair/catalog-data-fair/catalog-config",
+  "x-exports": [
+    "types",
+    "validate",
+    "schema"
+  ],
+  "title": "DataFairConfig",
+  "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 site où le catalogue est publié. *L'URL de l'API utilisée sera* *https*[]()*://example.com***/data-fair/api/v1**"
+      },
+      "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://example.com"]
+    }
+  }
+}