goblin-swiss 0.2.0

package/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*.{js,jsx,json}]
+indent_style = space
+indent_size = 2
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+max_line_length = 80

package/.zou-flow

@@ -0,0 +1,2 @@
+[update-version]
+	package-json = package.json

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Xcraft, Epsitec SA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+**goblin-swiss** brings Swiss domain logic to the Goblin actor ecosystem — with a clear, local-first model of the entities and specifics that make Switzerland unique.
+
+It provides a proud, pragmatic foundation for working with Swiss administrative concepts (like _Commune_ and _Canton_), identifiers, formats, and conventions — packaged as clean, reusable actors you can plug into your apps.
+
+Built for Swiss software, by people who care about getting Switzerland right. 🇨🇭

package/canton.js

@@ -0,0 +1,4 @@
+const {Elf} = require('xcraft-core-goblin');
+const {Canton, CantonLogic} = require('goblin-swiss/lib/canton.js');
+
+exports.xcraftCommands = Elf.birth(Canton, CantonLogic);

package/cantonAdmin.js

@@ -0,0 +1,7 @@
+const {Elf} = require('xcraft-core-goblin');
+const {
+  CantonAdmin,
+  CantonAdminLogic,
+} = require('goblin-swiss/lib/cantonAdmin.js');
+
+exports.xcraftCommands = Elf.birth(CantonAdmin, CantonAdminLogic);

package/commune.js

@@ -0,0 +1,4 @@
+const {Elf} = require('xcraft-core-goblin');
+const {Commune, CommuneLogic} = require('goblin-swiss/lib/commune.js');
+
+exports.xcraftCommands = Elf.birth(Commune, CommuneLogic);

package/config.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = [];

package/doc/sources.md

@@ -0,0 +1,28 @@
+# Sources de données
+
+## https://data.geo.admin.ch
+
+Cette route permet de trouver les "assets" des couches liées au NPA :
+
+https://data.geo.admin.ch/api/stac/v0.9/collections/ch.swisstopo-vd.ortschaftenverzeichnis_plz/items
+
+On peux trouver cette entrée qui contient le csv zippé avec toutes les données utiles pour nos entités :
+
+```json
+{
+  "assets": {
+    "ortschaftenverzeichnis_plz_4326.csv.zip": {
+      "type": "application/x.csv+zip",
+      "href": "https://data.geo.admin.ch/ch.swisstopo-vd.ortschaftenverzeichnis_plz/ortschaftenverzeichnis_plz/ortschaftenverzeichnis_plz_4326.csv.zip",
+      "created": "2023-05-17T05:30:59.121922Z",
+      "updated": "2026-03-01T03:14:24.717956Z",
+      "proj:epsg": 4326,
+      "checksum:multihash": "12209DE52BDA4BB2805EBBDDD6989536F96DA0572F7C504C39328E3572278210F43D"
+    }
+  }
+}
+```
+
+## https://sms.bfs.admin.ch/
+
+Cette source fournis les cantons, admin (district) et communes de Suisse sous forme d'un fichier CSV hiérarchisé.

package/lib/canton.js

@@ -0,0 +1,80 @@
+// @ts-check
+const {id} = require('xcraft-core-goblin/lib/types.js');
+const {Elf} = require('xcraft-core-goblin');
+const {string, option, array} = require('xcraft-core-stones');
+
+class MetaShape {
+  index = string;
+  status = string;
+  locale = string;
+  scope = string;
+}
+
+class CantonShape {
+  id = id('canton');
+  name = string;
+  code = string;
+  cantonAdminIds = array(id('cantonAdminId'));
+  communeIds = array(id('commune'));
+  meta = MetaShape;
+}
+
+class CantonState extends Elf.Sculpt(CantonShape) {}
+
+class CantonLogic extends Elf.Archetype {
+  static db = 'swiss';
+  static indices = [];
+
+  state = new CantonState();
+
+  create(id, porfolio) {
+    const {state} = this;
+    for (const [k, v] of Object.entries(porfolio)) {
+      state[k] = v;
+    }
+    state.id = id;
+  }
+
+  patch(patch) {
+    const {state} = this;
+    state._state.merge('', patch);
+  }
+
+  index(index) {
+    this.state.meta.index = index;
+  }
+}
+
+class Canton extends Elf {
+  logic = Elf.getLogic(CantonLogic);
+  state = new CantonState();
+
+  async create(id, desktopId, porfolio) {
+    this.logic.create(id, porfolio);
+    await this.index();
+    return this;
+  }
+
+  /**
+   * @param {Partial<this['state']>} patch
+   */
+  async patch(patch) {
+    this.logic.patch(patch);
+    await this.index();
+  }
+
+  async index() {
+    const index = `${this.state.code} ${this.state.name}`;
+    this.logic.index(index);
+    await this.persist();
+  }
+
+  delete() {}
+}
+
+module.exports = {
+  Canton,
+  CantonLogic,
+  CantonShape,
+  CantonState,
+};

package/lib/cantonAdmin.js

@@ -0,0 +1,81 @@
+// @ts-check
+const {id} = require('xcraft-core-goblin/lib/types.js');
+const {Elf} = require('xcraft-core-goblin');
+const {string, array} = require('xcraft-core-stones');
+
+class MetaShape {
+  index = string;
+  status = string;
+  locale = string;
+  scope = string;
+}
+
+class CantonAdminShape {
+  id = id('cantonAdmin');
+  name = string;
+  cantonId = id('canton');
+  cantonCode = string;
+  cantonName = string;
+  communeIds = array(id('commune'));
+  meta = MetaShape;
+}
+
+class CantonAdminState extends Elf.Sculpt(CantonAdminShape) {}
+
+class CantonAdminLogic extends Elf.Archetype {
+  static db = 'swiss';
+  static indices = [];
+
+  state = new CantonAdminState();
+
+  create(id, porfolio) {
+    const {state} = this;
+    for (const [k, v] of Object.entries(porfolio)) {
+      state[k] = v;
+    }
+    state.id = id;
+  }
+
+  patch(patch) {
+    const {state} = this;
+    state._state.merge('', patch);
+  }
+
+  index(index) {
+    this.state.meta.index = index;
+  }
+}
+
+class CantonAdmin extends Elf {
+  logic = Elf.getLogic(CantonAdminLogic);
+  state = new CantonAdminState();
+
+  async create(id, desktopId, porfolio) {
+    this.logic.create(id, porfolio);
+    await this.index();
+    return this;
+  }
+
+  /**
+   * @param {Partial<this['state']>} patch
+   */
+  async patch(patch) {
+    this.logic.patch(patch);
+    await this.index();
+  }
+
+  async index() {
+    const index = `${this.state.name}`;
+    this.logic.index(index);
+    await this.persist();
+  }
+
+  delete() {}
+}
+
+module.exports = {
+  CantonAdmin,
+  CantonAdminLogic,
+  CantonAdminShape,
+  CantonAdminState,
+};

package/lib/commune.js

@@ -0,0 +1,84 @@
+// @ts-check
+const {id} = require('xcraft-core-goblin/lib/types.js');
+const {Elf} = require('xcraft-core-goblin');
+const {string, option, array} = require('xcraft-core-stones');
+
+class MetaShape {
+  index = string;
+  status = string;
+  locale = string;
+  scope = string;
+}
+
+class CommuneShape {
+  id = id('commune');
+  name = string;
+  cantonId = option(id('canton'));
+  cantonCode = string;
+  cantonName = string;
+  cantonAdminId = option(id('cantonAdmin'));
+  cantonAdminName = string;
+  postalCodeIds = array(id('postalCode'));
+  languages = array(string);
+  meta = MetaShape;
+}
+
+class CommuneState extends Elf.Sculpt(CommuneShape) {}
+
+class CommuneLogic extends Elf.Archetype {
+  static db = 'swiss';
+  static indices = [];
+
+  state = new CommuneState();
+
+  create(id, porfolio) {
+    const {state} = this;
+    for (const [k, v] of Object.entries(porfolio)) {
+      state[k] = v;
+    }
+    state.id = id;
+  }
+
+  patch(patch) {
+    const {state} = this;
+    state._state.merge('', patch);
+  }
+
+  index(index) {
+    this.state.meta.index = index;
+  }
+}
+
+class Commune extends Elf {
+  logic = Elf.getLogic(CommuneLogic);
+  state = new CommuneState();
+
+  async create(id, desktopId, porfolio) {
+    this.logic.create(id, porfolio);
+    await this.index();
+    return this;
+  }
+
+  /**
+   * @param {Partial<this['state']>} patch
+   */
+  async patch(patch) {
+    this.logic.patch(patch);
+    await this.index();
+  }
+
+  async index() {
+    const index = `${this.state.name}`;
+    this.logic.index(index);
+    await this.persist();
+  }
+
+  delete() {}
+}
+
+module.exports = {
+  Commune,
+  CommuneLogic,
+  CommuneShape,
+  CommuneState,
+};

package/lib/getAddress.js

@@ -0,0 +1,70 @@
+const BASE_URL = 'https://api3.geo.admin.ch/rest/services/ech/MapServer/find';
+
+const LAYER = 'ch.swisstopo.amtliches-gebaeudeadressverzeichnis';
+
+/**
+ * Resolve a structured address from a GeoAdmin SearchServer featureId.
+ *
+ * @param {string} featureId - SearchServer featureId, e.g. "1487827_0".
+ * @param {AbortSignal} [signal] - Optional abort signal.
+ * @returns {Promise<{
+ *   street: string|null,
+ *   houseNumber: string|null,
+ *   zip: string|null,
+ *   city: string|null,
+ *   municipality: string|null,
+ *   municipalityId: number|null,
+ *   egid: number|null,
+ *   edid: number|null,
+ *   egaid: number|null
+ * }|null>}
+ */
+async function getAddress(featureId, signal) {
+  const [egid, edid = '0'] = String(featureId).split('_');
+
+  const params = new URLSearchParams({
+    layer: LAYER,
+    searchText: egid,
+    searchField: 'bdg_egid',
+    contains: 'false',
+    returnGeometry: 'false',
+    lang: 'fr',
+  });
+
+  const response = await fetch(`${BASE_URL}?${params}`, {
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `GeoAdmin lookup failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  const data = await response.json();
+
+  const candidates = data.results ?? [];
+
+  const result =
+    candidates.find(
+      ({attributes}) => String(attributes?.adr_edid ?? '0') === edid
+    ) ?? candidates[0];
+
+  if (!result) {
+    return null;
+  }
+
+  const attrs = result.attributes ?? {};
+
+  return {
+    street: attrs.stn_label ?? attrs.str_label ?? null,
+    houseNumber: attrs.adr_number ?? null,
+    municipality: attrs.com_name ?? null,
+    municipalityId: attrs.com_fosnr ?? null,
+    egid: attrs.bdg_egid ?? null,
+    edid: attrs.adr_edid ?? null,
+    egaid: attrs.adr_egaid ?? null,
+  };
+}
+
+module.exports = getAddress;

package/lib/postalCode.js

@@ -0,0 +1,87 @@
+// @ts-check
+const {id} = require('xcraft-core-goblin/lib/types.js');
+const {Elf} = require('xcraft-core-goblin');
+const {string, option} = require('xcraft-core-stones');
+
+class MetaShape {
+  index = string;
+  status = string;
+  locale = string;
+  scope = string;
+}
+
+class PostalCodeShape {
+  id = id('postalCode');
+  zipId = string;
+  zipCode = string;
+  zipCodeAddon = string;
+  name = string;
+  lat = string;
+  long = string;
+  language = string;
+  coverage = string;
+  communeId = option(id('commune'));
+  cantonAdminId = option(id('cantonAdmin'));
+  cantonId = option(id('canton'));
+  meta = MetaShape;
+}
+
+class PostalCodeState extends Elf.Sculpt(PostalCodeShape) {}
+
+class PostalCodeLogic extends Elf.Archetype {
+  static db = 'swiss';
+  static indices = ['communeId', 'cantonId'];
+
+  state = new PostalCodeState();
+
+  create(id, porfolio) {
+    const {state} = this;
+    for (const [k, v] of Object.entries(porfolio)) {
+      state[k] = v;
+    }
+    state.id = id;
+  }
+
+  patch(patch) {
+    const {state} = this;
+    state._state.merge('', patch);
+  }
+
+  index(index) {
+    this.state.meta.index = index;
+  }
+}
+
+class PostalCode extends Elf {
+  logic = Elf.getLogic(PostalCodeLogic);
+  state = new PostalCodeState();
+
+  async create(id, desktopId, porfolio) {
+    this.logic.create(id, porfolio);
+    await this.index();
+    return this;
+  }
+
+  /**
+   * @param {Partial<this['state']>} patch
+   */
+  async patch(patch) {
+    this.logic.patch(patch);
+    await this.index();
+  }
+
+  async index() {
+    const index = `${this.state.zipCode} ${this.state.name}`;
+    this.logic.index(index);
+    await this.persist();
+  }
+
+  delete() {}
+}
+
+module.exports = {
+  PostalCode,
+  PostalCodeLogic,
+  PostalCodeShape,
+  PostalCodeState,
+};

package/lib/searchAddresses.js

@@ -0,0 +1,73 @@
+const BASE_URL = 'https://api3.geo.admin.ch/rest/services/ech/SearchServer';
+
+/**
+ * Search for Swiss addresses using the GeoAdmin SearchServer API.
+ *
+ * The search can be narrowed by postal code and city.
+ *
+ * @param {string} searchText - Partial or complete address to search for.
+ * @param {Object} [options={}] - Search options.
+ * @param {string} [options.zip] - Swiss postal code (NPA), e.g. "2560".
+ * @param {string} [options.city] - City name, e.g. "Nidau".
+ * @param {string} [options.lang="fr"] - Result language.
+ * @param {AbortSignal} [options.signal] - Optional signal used to abort the request.
+ *
+ * @returns {Promise<Array<{
+ *   id: string|number,
+ *   lat: number,
+ *   lng: number,
+ *   label: string
+ * }>>} Matching addresses.
+ *
+ * @throws {Error} If the GeoAdmin request fails.
+ */
+async function searchAddresses(
+  searchText,
+  {zip, city, lang = 'fr', signal} = {}
+) {
+  if (!searchText?.trim()) {
+    return [];
+  }
+
+  const location = [searchText, zip, city].filter(Boolean).join(' ');
+
+  const params = new URLSearchParams({
+    searchText: location,
+    type: 'locations',
+    origins: 'address',
+    lang,
+  });
+
+  const response = await fetch(`${BASE_URL}?${params}`, {
+    method: 'GET',
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `GeoAdmin search failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  const data = await response.json();
+
+  return parseResults(data);
+}
+
+function parseResults(data) {
+  return (data.results ?? []).map(({id, attrs}) => ({
+    id: attrs.featureId,
+    lat: attrs.lat,
+    lon: attrs.lon,
+    label: cleanLabel(attrs.label),
+  }));
+}
+
+function cleanLabel(label = '') {
+  return label
+    .replace(/<[^>]+>/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+module.exports = searchAddresses;

package/lib/swiss.js

@@ -0,0 +1,406 @@
+// @ts-check
+const {Elf} = require('xcraft-core-goblin');
+const {id} = require('xcraft-core-goblin/lib/types.js');
+const {pipeline} = require('node:stream/promises');
+const {
+  createSwissAdminCsvTransform,
+  createGeoDataEntryConsumer,
+} = require('./utils.js');
+const Batcher = require('xcraft-core-utils/lib/batcher.js');
+const {
+  PostalCodeLogic,
+  PostalCode,
+  PostalCodeShape,
+} = require('./postalCode.js');
+const {Canton} = require('./canton.js');
+const {Commune, CommuneLogic} = require('./commune.js');
+const {CantonAdmin} = require('./cantonAdmin.js');
+
+function parseAutocompleteInput(input) {
+  const q = String(input ?? '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .trim();
+
+  if (!q) {
+    return null;
+  }
+
+  const tokens = q
+    .split(/\s+/)
+    .map((token) => token.replace(/[^a-z0-9]/g, ''))
+    .filter(Boolean)
+    .slice(0, 5);
+
+  if (!tokens.length) {
+    return null;
+  }
+
+  return tokens.map((token) => `${token}*`).join(' ');
+}
+
+class SwissShape {
+  id = id;
+}
+
+class SwissState extends Elf.Sculpt(SwissShape) {}
+
+class SwissLogic extends Elf.Spirit {
+  state = new SwissState({
+    id: 'swiss',
+  });
+}
+
+class Swiss extends Elf.Alone {
+  logic = Elf.getLogic(SwissLogic);
+  state = new SwissState();
+  /** @type {Set<Batcher>} */ _batchers = new Set();
+
+  async init() {
+    this.log.dbg('Pain, fromage et viande séchée...');
+    const bestCommuneOfSwitzerlandExist = await this.cryo.isPersisted(
+      CommuneLogic.db,
+      'commune@6512'
+    );
+    if (!bestCommuneOfSwitzerlandExist) {
+      await this.loadEntities();
+    }
+  }
+
+  async searchPostalCode(input) {
+    const query = parseAutocompleteInput(input);
+    if (!query) {
+      return [];
+    }
+    const searchResults = await this.cryo.search2(
+      PostalCodeLogic.db,
+      query,
+      ['fr'],
+      ['postalCode'],
+      10
+    );
+    const results = [];
+    for (const result of searchResults) {
+      const postalCode = await this.cryo.getState(
+        PostalCodeLogic.db,
+        result.documentId,
+        PostalCodeShape
+      );
+      results.push(postalCode);
+    }
+
+    return results;
+  }
+
+  async loadEntities() {
+    this.log.dbg('Loading swiss entities...');
+    const postalCodesByCommuneId = await this.loadSwissGeoData();
+
+    const {communes, admins, cantons} = await this.loadSwissAdmin();
+    const communesToInsert = [];
+    const adminsToInsert = [];
+    const cantonsToInsert = [];
+
+    const communesById = {};
+    const communesByAdminId = {};
+    const communesByCantonId = {};
+    const adminsByCantonId = {};
+
+    this.log.dbg('Make federalism great again...');
+    for (const commune of Object.values(communes)) {
+      const admin = admins[commune.cantonAdminId];
+      if (!admin) {
+        throw new Error('Data loading error');
+      }
+      const canton = cantons[admin.cantonId];
+      if (!canton) {
+        throw new Error('Data loading error');
+      }
+
+      if (!communesByAdminId[commune.cantonAdminId]) {
+        communesByAdminId[commune.cantonAdminId] = [];
+      }
+      communesByAdminId[commune.cantonAdminId].push(commune.id);
+
+      if (!communesByCantonId[canton.id]) {
+        communesByCantonId[canton.id] = [];
+      }
+      communesByCantonId[canton.id].push(commune.id);
+
+      let postalCodeIds = [];
+      let languages = [];
+      const postalCodes = postalCodesByCommuneId[commune.id];
+      if (postalCodes) {
+        postalCodeIds = postalCodes.map((p) => p.id);
+        languages = postalCodes.reduce((languages, p) => {
+          if (!languages.includes(p.lang)) {
+            languages.push(p.lang);
+          }
+          return languages;
+        }, []);
+      }
+
+      const communeState = {
+        id: commune.id,
+        name: commune.name,
+        cantonId: canton.id,
+        cantonCode: canton.code,
+        cantonName: canton.name,
+        cantonAdminId: commune.cantonAdminId,
+        cantonAdminName: admin.name,
+        postalCodeIds,
+        languages,
+        meta: {
+          status: 'published',
+          index: commune.name,
+          locale: 'fr',
+          scope: 'commune',
+        },
+      };
+      communesById[commune.id] = communeState;
+      communesToInsert.push(communeState);
+    }
+
+    for (const admin of Object.values(admins)) {
+      const canton = cantons[admin.cantonId];
+      if (!adminsByCantonId[admin.cantonId]) {
+        adminsByCantonId[admin.cantonId] = [];
+      }
+      adminsByCantonId[admin.cantonId].push(admin.id);
+      adminsToInsert.push({
+        id: admin.id,
+        name: admin.name,
+        cantonId: canton.id,
+        cantonCode: canton.code,
+        cantonName: canton.name,
+        communeIds: communesByAdminId[admin.id],
+        meta: {
+          status: 'published',
+          index: admin.name,
+          locale: 'fr',
+          scope: 'admin',
+        },
+      });
+    }
+
+    for (const canton of Object.values(cantons)) {
+      cantonsToInsert.push({
+        id: canton.id,
+        name: canton.name,
+        code: canton.code,
+        cantonAdminIds: adminsByCantonId[canton.id],
+        communeIds: communesByCantonId[canton.id],
+        meta: {
+          status: 'published',
+          index: `${canton.code} ${canton.name}`,
+          locale: 'fr',
+          scope: 'canton',
+        },
+      });
+    }
+
+    this.log.dbg('Adressing switzerland ...');
+    const postalCodeToInsert = [];
+    for (const postalCodes of Object.values(postalCodesByCommuneId)) {
+      for (const postalCode of postalCodes) {
+        const commune = communesById[postalCode.communeId];
+        let cantonId = null;
+        let cantonAdminId = null;
+        if (commune) {
+          cantonId = commune.cantonId;
+          cantonAdminId = commune.cantonAdminId;
+        }
+
+        postalCodeToInsert.push({
+          id: postalCode.id,
+          zipId: postalCode.zipId,
+          zipCode: postalCode.zip,
+          zipCodeAddon: postalCode.zipAddon,
+          name: postalCode.name,
+          lat: postalCode.lat,
+          long: postalCode.long,
+          language: postalCode.lang,
+          coverage: postalCode.coverage,
+          communeId: postalCode.communeId,
+          cantonAdminId,
+          cantonId,
+          meta: {
+            status: 'published',
+            index: `${postalCode.zip} ${postalCode.name}`,
+            locale: 'fr',
+            scope: 'postalCode',
+          },
+        });
+      }
+    }
+
+    const cryo = this.quest.getAPI('cryo');
+    const batcher = new Batcher(
+      async () => {
+        this.log.dbg(`Swiss entities begin transaction`);
+        await cryo.begin({db: PostalCodeLogic.db});
+      },
+      async (batch) => {
+        this.log.dbg(`Swiss entities commit transaction (batch of ${batch})`);
+        await cryo.commit({db: PostalCodeLogic.db});
+      }
+    );
+    this._batchers.add(batcher);
+
+    await batcher.start();
+    this.quest.defer(async () => {
+      this._batchers.delete(batcher);
+      await batcher.stop();
+      this.log.dbg(`End load entities`);
+    });
+
+    const feedId = await this.newQuestFeed();
+    for (const postalCode of postalCodeToInsert) {
+      if (!(await batcher.pump())) {
+        break;
+      }
+
+      await new PostalCode(this).insertOrReplace(
+        postalCode.id,
+        feedId,
+        postalCode
+      );
+
+      if (!(await batcher.bump())) {
+        break;
+      }
+    }
+
+    for (const canton of cantonsToInsert) {
+      if (!(await batcher.pump())) {
+        break;
+      }
+
+      await new Canton(this).insertOrReplace(canton.id, feedId, canton);
+
+      if (!(await batcher.bump())) {
+        break;
+      }
+    }
+
+    for (const commune of communesToInsert) {
+      if (!(await batcher.pump())) {
+        break;
+      }
+
+      await new Commune(this).insertOrReplace(commune.id, feedId, commune);
+
+      if (!(await batcher.bump())) {
+        break;
+      }
+    }
+
+    for (const admin of adminsToInsert) {
+      if (!(await batcher.pump())) {
+        break;
+      }
+
+      await new CantonAdmin(this).insertOrReplace(admin.id, feedId, admin);
+
+      if (!(await batcher.bump())) {
+        break;
+      }
+    }
+
+    this.log.dbg('Swiss entities loaded !');
+  }
+
+  async loadSwissGeoData() {
+    const url =
+      'https://data.geo.admin.ch/ch.swisstopo-vd.ortschaftenverzeichnis_plz/ortschaftenverzeichnis_plz/ortschaftenverzeichnis_plz_4326.csv.zip';
+    const res = await fetch(url);
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+
+    if (!res.body) {
+      throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+
+    this.log.dbg('Fetching and unzipping swiss geo data...');
+    const unzipper = require('unzipper');
+    const geoData = [];
+    try {
+      await pipeline(
+        res.body,
+        unzipper.Parse(),
+        createGeoDataEntryConsumer(geoData)
+      );
+    } catch (err) {
+      this.log.err(err);
+    }
+    geoData.splice(0, 1);
+    return geoData.reduce((state, z) => {
+      const key = z.communeId || 'ext'; //communeId can be null (ex. lichtenstein zip codes)
+      if (!state[key]) {
+        state[key] = [];
+      }
+      state[key].push(z);
+      return state;
+    }, {});
+  }
+
+  async loadSwissAdmin() {
+    const communes = [];
+    const cantons = [];
+    const admins = [];
+    const n = new Date();
+    const snapshotDate = `${n.getDate()}-${
+      n.getMonth() + 1
+    }-${n.getFullYear()}`;
+    const url = `https://sms.bfs.admin.ch/WcfBFSSpecificService.svc/AnonymousRest/communes/snapshots?format=Csv&useBfsCode=true&startPeriod=${snapshotDate}&endPeriod=${snapshotDate}`;
+    const res = await fetch(url);
+
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status} ${res.statusText}`);
+    }
+
+    try {
+      this.log.dbg('Fetching and unzipping swiss admin data...');
+      await pipeline(
+        res.body,
+        createSwissAdminCsvTransform(communes, admins, cantons)
+      );
+    } catch (err) {
+      this.log.err(err);
+    }
+
+    return {
+      communes: communes.reduce((state, c) => {
+        if (!state[c.id]) {
+          state[c.id] = c;
+        } else {
+          throw new Error('Duplicate commune infos');
+        }
+
+        return state;
+      }, {}),
+      admins: admins.reduce((state, c) => {
+        if (!state[c.id]) {
+          state[c.id] = c;
+        } else {
+          throw new Error('Duplicate admin infos');
+        }
+
+        return state;
+      }, {}),
+      cantons: cantons.reduce((state, c) => {
+        if (!state[c.id]) {
+          state[c.id] = c;
+        } else {
+          throw new Error('Duplicate canton infos');
+        }
+
+        return state;
+      }, {}),
+    };
+  }
+}
+
+module.exports = {Swiss, SwissLogic};

package/lib/utils.js

@@ -0,0 +1,204 @@
+const {Transform} = require('node:stream');
+const {pipeline} = require('node:stream/promises');
+
+const isOutside = (c) => ['FL', 'IT', 'DE', ''].includes(c);
+
+function createGeoDataCsvParser(geoData) {
+  let leftover = '';
+
+  const buildRow = (geoData, columns) => {
+    const [
+      name,
+      zip,
+      zipAddon,
+      zipId,
+      communeName,
+      communeSourceId,
+      cantonCode,
+      coverage,
+      lat,
+      long,
+      lang,
+      validity,
+    ] = columns;
+
+    const communeId = isOutside(cantonCode)
+      ? null
+      : `commune@${communeSourceId}`;
+
+    geoData.push({
+      id: communeId
+        ? `postalCode@${communeId}@${zipId}` //swiss postalCode
+        : `postalCode@ext@${zipId}`, //non-swiss
+      name,
+      zip,
+      zipAddon,
+      zipId,
+      communeName,
+      communeId,
+      cantonCode,
+      coverage,
+      lat,
+      long,
+      lang,
+      validity,
+    });
+  };
+
+  return new Transform({
+    transform(chunk, _enc, cb) {
+      try {
+        let data = chunk.toString('utf8');
+        if (leftover) {
+          data = leftover + data;
+          leftover = '';
+        }
+
+        const lines = data.split(/\n/);
+        leftover = lines.pop() ?? '';
+
+        for (let line of lines) {
+          line = line.replace(/\r$/, '');
+          if (!line) continue;
+
+          const columns = line.split(';');
+          buildRow(geoData, columns);
+        }
+
+        cb();
+      } catch (err) {
+        cb(err);
+      }
+    },
+
+    flush(cb) {
+      try {
+        const line = leftover.replace(/\r$/, '');
+        leftover = '';
+        if (!line) return cb();
+
+        const columns = line.split(';');
+        if (columns.length === 16 && columns[0] === '01') {
+          buildRow(geoData, columns);
+        }
+
+        cb();
+      } catch (err) {
+        cb(err);
+      }
+    },
+  });
+}
+
+function createGeoDataEntryConsumer(geoData) {
+  return new Transform({
+    objectMode: true,
+
+    async transform(entry, _enc, cb) {
+      try {
+        if (!entry?.path) {
+          entry.autodrain?.();
+          return cb();
+        }
+        await pipeline(entry, createGeoDataCsvParser(geoData));
+        cb();
+      } catch (err) {
+        entry?.autodrain?.();
+        cb(err);
+      }
+    },
+  });
+}
+
+function createSwissAdminCsvTransform(communes, admins, cantons) {
+  let leftover = '';
+
+  const clean = (s) => {
+    if (!s) return s;
+    if (s.length >= 2 && s[0] === '"' && s[s.length - 1] === '"') {
+      return s.slice(1, -1);
+    }
+    return s;
+  };
+
+  const handleLine = (line) => {
+    line = line.replace(/\r$/, '');
+    if (!line) return;
+
+    const columns = line.split(',');
+    if (columns.length !== 29) return;
+
+    const [
+      id,
+      _vf,
+      _vt,
+      lvl,
+      _p,
+      _nameEn,
+      nameFr,
+      nameDe,
+      nameIt,
+      abbEn,
+      abbFr,
+    ] = columns;
+
+    if (id !== 'Identifier' && lvl === '"1"') {
+      cantons.push({
+        id: `canton@${clean(id)}`,
+        name: clean(nameFr),
+        code: clean(abbFr),
+      });
+    }
+
+    if (id !== 'Identifier' && lvl === '"2"') {
+      admins.push({
+        id: `cantonAdmin@${clean(id)}`,
+        name: clean(nameFr),
+        cantonId: `canton@${clean(_p)}`,
+      });
+    }
+
+    if (id !== 'Identifier' && lvl === '"3"') {
+      communes.push({
+        id: `commune@${clean(id)}`,
+        name: clean(nameFr),
+        cantonAdminId: `cantonAdmin@${clean(_p)}`,
+      });
+    }
+  };
+
+  return new Transform({
+    transform(chunk, _enc, cb) {
+      try {
+        let data = chunk.toString();
+        if (leftover) {
+          data = leftover + data;
+          leftover = '';
+        }
+
+        const lines = data.split(/\n/);
+        leftover = lines.pop() || '';
+
+        for (const line of lines) handleLine(line);
+        cb();
+      } catch (err) {
+        cb(err);
+      }
+    },
+
+    flush(cb) {
+      try {
+        if (leftover) handleLine(leftover);
+        leftover = '';
+        cb();
+      } catch (err) {
+        cb(err);
+      }
+    },
+  });
+}
+
+module.exports = {
+  createGeoDataEntryConsumer,
+  createSwissAdminCsvTransform,
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "goblin-swiss",
+  "version": "0.2.0",
+  "description": "Swiss stuff",
+  "author": "Epsitec SA",
+  "contributors": [
+    "Samuel Loup <loup@epsitec.ch>"
+  ],
+  "license": "MIT",
+  "config": {
+    "xcraft": {
+      "commands": true
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "xcraft-core-goblin": "^5.8.0",
+    "xcraft-core-utils": "^4.14.0",
+    "unzipper": "^0.12.3"
+  },
+  "devDependencies": {
+    "xcraft-dev-prettier": "^2.0.0",
+    "xcraft-dev-rules": "^4.4.2"
+  },
+  "prettier": "xcraft-dev-prettier"
+}

package/postalCode.js

@@ -0,0 +1,4 @@
+const {Elf} = require('xcraft-core-goblin');
+const {PostalCode, PostalCodeLogic} = require('goblin-swiss/lib/postalCode.js');
+
+exports.xcraftCommands = Elf.birth(PostalCode, PostalCodeLogic);

package/swiss.js

@@ -0,0 +1,4 @@
+const {Elf} = require('xcraft-core-goblin');
+const {Swiss, SwissLogic} = require('goblin-swiss/lib/swiss.js');
+
+exports.xcraftCommands = Elf.birth(Swiss, SwissLogic);

package/test/swiss.spec.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const {expect} = require('chai');
+const {Elf} = require('xcraft-core-goblin/lib/test.js');
+const {Swiss} = require('../lib/swiss.js');
+
+describe('goblin.swiss', function () {
+  let runner;
+
+  this.beforeAll(function () {
+    runner = new Elf.Runner();
+    runner.init();
+  });
+
+  this.afterAll(function () {
+    runner.dispose();
+  });
+
+  it.skip('load swisspost zips', async function () {
+    this.timeout(process.env.NODE_ENV === 'development' ? 1000000 : 40000);
+
+    /** @this {Elf} */
+    async function testLoad() {
+      const swiss = new Swiss(this);
+      await swiss.boot();
+      const results = await swiss.searchPostalCode('z*');
+      this.log.dbg(results);
+    }
+
+    await runner.it(testLoad);
+  });
+});