@opencitylabs/formio-sdk 1.0.0

package/README.md

@@ -0,0 +1,56 @@
+# formio-sdk
+
+Node/browser helper utilities for Form.io APIs.
+
+## Install
+
+```bash
+npm install formio-sdk
+```
+
+## Quick start (Node)
+
+```js
+const { FormioHelper } = require("formio-sdk");
+
+const helper = new FormioHelper({
+  baseUrl: "https://servizi.example.it/lang",
+  token: process.env.AUTH_TOKEN,
+  locale: "it",
+  siteUrl: "https://servizi.example.it",
+  applicationId: "12345"
+});
+
+async function run() {
+  const tenant = await helper.getTenantInfo();
+  console.log("tenant:", tenant);
+
+  const profile = await helper.authenticatedCall("users/me");
+  console.log("profile:", profile);
+}
+
+run().catch(console.error);
+```
+
+## API notes
+
+- `getFieldApplication(getParams, applicationId)`
+: in Node pass `applicationId` as argument or constructor option.
+- `getFieldMeta(getParams)`
+: returns parsed tenant meta (or nested key via lodash path).
+- `authenticatedCall`, `authenticatedPOSTCall`, `authenticatedRequest`
+: return `undefined` when token is missing (same behavior as original helper).
+
+## Constructor options
+
+- `baseUrl`: Formio backend base URL.
+- `token`: auth token string (or function returning token).
+- `locale`: locale string (defaults to `it`).
+- `siteUrl`: optional site URL used by `getBookingConfig`.
+- `applicationId`: fallback id used by `getFieldApplication`.
+- `origin`: base origin for relative URLs in `addLimitParam`.
+- `storage`: custom storage adapter (`getItem`) to read `auth-token`.
+- `httpClient`: custom axios-like client.
+- `logger`: custom logger with `error`/`warn` methods.
+- `getBaseUrl`, `getCurrentToken`, `getCurrentLocale`, `getSiteUrl`
+: override functions for full control.

package/index.js

@@ -0,0 +1,671 @@
+"use strict";
+
+const axios = require("axios");
+const get = require("lodash.get");
+
+class FormioHelper {
+  constructor(options = {}) {
+    this.options = options;
+    this.httpClient = options.httpClient || axios;
+    this.logger = options.logger || console;
+    this.token = null;
+    this.basePath = null;
+    this.init();
+  }
+
+  init() {
+    this.basePath = this.getBaseUrl();
+    this.token = this.getCurrentToken();
+  }
+
+  logError(...args) {
+    if (this.logger && typeof this.logger.error === "function") {
+      this.logger.error(...args);
+    }
+  }
+
+  logWarn(...args) {
+    if (this.logger && typeof this.logger.warn === "function") {
+      this.logger.warn(...args);
+    }
+  }
+
+  getWindow() {
+    return typeof window !== "undefined" ? window : null;
+  }
+
+  getDocument() {
+    return typeof document !== "undefined" ? document : null;
+  }
+
+  getStorage() {
+    if (this.options.storage) {
+      return this.options.storage;
+    }
+
+    const win = this.getWindow();
+    if (win && win.sessionStorage) {
+      return win.sessionStorage;
+    }
+
+    return null;
+  }
+
+  resolveOption(optionName) {
+    const optionValue = this.options[optionName];
+    if (typeof optionValue === "function") {
+      return optionValue();
+    }
+
+    return optionValue ?? null;
+  }
+
+  getCurrentLocale() {
+    if (typeof this.options.getCurrentLocale === "function") {
+      return this.options.getCurrentLocale();
+    }
+
+    const optionLocale = this.resolveOption("locale");
+    if (optionLocale) {
+      return optionLocale.toString();
+    }
+
+    const doc = this.getDocument();
+    if (doc && doc.documentElement && doc.documentElement.lang) {
+      return doc.documentElement.lang.toString();
+    }
+
+    return "it";
+  }
+
+  getCurrentToken() {
+    if (this.token) {
+      return this.token;
+    }
+
+    if (typeof this.options.getCurrentToken === "function") {
+      return this.options.getCurrentToken();
+    }
+
+    const optionToken = this.resolveOption("token");
+    if (typeof optionToken === "string") {
+      return optionToken;
+    }
+
+    if (optionToken && typeof optionToken === "object") {
+      return optionToken.value || null;
+    }
+
+    const storage = this.getStorage();
+    if (!storage || typeof storage.getItem !== "function") {
+      return null;
+    }
+
+    const rawToken = storage.getItem("auth-token");
+    if (!rawToken) {
+      return null;
+    }
+
+    try {
+      const parsedToken = JSON.parse(rawToken);
+      if (typeof parsedToken === "string") {
+        return parsedToken;
+      }
+
+      return parsedToken && parsedToken.value ? parsedToken.value : null;
+    } catch (error) {
+      return rawToken;
+    }
+  }
+
+  getBaseUrl() {
+    if (typeof this.options.getBaseUrl === "function") {
+      return this.options.getBaseUrl();
+    }
+
+    const optionBaseUrl = this.resolveOption("baseUrl");
+    if (optionBaseUrl) {
+      return optionBaseUrl;
+    }
+
+    const win = this.getWindow();
+    if (win && win.BASE_URL) {
+      return win.BASE_URL;
+    }
+
+    if (win && win.location && win.location.origin && win.location.pathname) {
+      const explodedPath = win.location.pathname.split("/");
+      return `${win.location.origin}/${explodedPath[1]}`;
+    }
+
+    return null;
+  }
+
+  getSiteUrl() {
+    if (typeof this.options.getSiteUrl === "function") {
+      return this.options.getSiteUrl();
+    }
+
+    const optionSiteUrl = this.resolveOption("siteUrl");
+    if (optionSiteUrl) {
+      return optionSiteUrl;
+    }
+
+    const win = this.getWindow();
+    if (win && win.SITE_URL) {
+      return win.SITE_URL;
+    }
+
+    return null;
+  }
+
+  buildApiUrl(endPoint = "") {
+    const baseUrl = this.getBaseUrl();
+    if (!baseUrl) {
+      throw new Error("Missing baseUrl. Pass { baseUrl } to FormioHelper.");
+    }
+
+    const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+    const normalizedEndpoint = endPoint.toString().replace(/^\/+/, "");
+    return `${normalizedBaseUrl}/api/${normalizedEndpoint}`;
+  }
+
+  async getTenantInfo() {
+    const response = await this.httpClient.get(this.buildApiUrl("tenants/info"), {
+      headers: {
+        "x-locale": this.getCurrentLocale(),
+      },
+    });
+
+    return response.data;
+  }
+
+  async authenticatedCall(endPoint) {
+    const token = this.getCurrentToken();
+    if (!token) {
+      return;
+    }
+
+    const response = await this.httpClient.get(this.buildApiUrl(endPoint), {
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+    });
+
+    return response.data;
+  }
+
+  async authenticatedPOSTCall(endPoint, params) {
+    const token = this.getCurrentToken();
+    if (!token) {
+      return;
+    }
+
+    const response = await this.httpClient.post(
+      this.buildApiUrl(endPoint),
+      JSON.stringify(params),
+      {
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+      },
+    );
+
+    return response.data;
+  }
+
+  async authenticatedRequest(method, endPoint, params = {}) {
+    const token = this.getCurrentToken();
+    if (!token) {
+      return;
+    }
+
+    try {
+      const response = await this.httpClient({
+        method,
+        url: this.buildApiUrl(endPoint),
+        data: params,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${token}`,
+        },
+      });
+
+      return response.data;
+    } catch (error) {
+      this.logError(`Error on ${method.toUpperCase()} ${endPoint}:`, error);
+      throw error;
+    }
+  }
+
+  async postGraphql(url, method = "post", payload) {
+    const graphqlQuery = {
+      operationName: "fetchList",
+      query: `${payload}`,
+      variables: {},
+    };
+
+    const response = await this.httpClient({
+      url,
+      method,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      data: graphqlQuery,
+    });
+
+    return response.data;
+  }
+
+  async getRemoteJson(url, method = "get", headers = null) {
+    const requestConfig = {
+      method,
+      url,
+    };
+
+    if (headers) {
+      requestConfig.headers = headers;
+    }
+
+    const response = await this.httpClient(requestConfig);
+    return response.data;
+  }
+
+  async anonymousCall(endPoint) {
+    const response = await this.httpClient.get(this.buildApiUrl(endPoint), {
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+
+    return response.data;
+  }
+
+  // See Doc {@link https://gitlab.com/opencity-labs/area-personale/core/-/wikis/Guida-alla-creazione-dei-moduli/Form.io-Sdk#esempio-recupero-dato-dai-meta}
+  async getFieldMeta(getParams) {
+    try {
+      const result = await this.getTenantInfo();
+      const rawMeta = Array.isArray(result && result.meta) ? result.meta[0] : null;
+      if (!rawMeta) {
+        return null;
+      }
+
+      const meta = JSON.parse(rawMeta);
+      if (!meta) {
+        return null;
+      }
+
+      if (getParams) {
+        return get(meta, getParams, false);
+      }
+
+      return meta;
+    } catch (error) {
+      this.logError("error getFieldMeta", error);
+      return null;
+    }
+  }
+
+  readApplicationIdFromDom() {
+    const doc = this.getDocument();
+    if (!doc) {
+      return null;
+    }
+
+    const formioElement = doc.querySelector("#formio");
+    return formioElement && formioElement.dataset
+      ? formioElement.dataset.applicationId || null
+      : null;
+  }
+
+  async getFieldApplication(getParams, applicationId = null) {
+    const resolvedApplicationId =
+      applicationId ||
+      this.resolveOption("applicationId") ||
+      this.readApplicationIdFromDom();
+
+    if (!resolvedApplicationId) {
+      this.logWarn("No applicationId provided to getFieldApplication");
+      return null;
+    }
+
+    try {
+      const result = await this.authenticatedCall(
+        `applications/${resolvedApplicationId}`,
+      );
+
+      if (result && getParams) {
+        return get(result, getParams);
+      }
+
+      return result;
+    } catch (error) {
+      this.logError("error getFieldApplication", error);
+      return null;
+    }
+  }
+
+  addLimitParam(url, limit) {
+    const origin = this.resolveOption("origin") || this.getWindow()?.location?.origin;
+    const parsedUrl = origin ? new URL(url, origin) : new URL(url);
+    parsedUrl.searchParams.set("limit", String(limit));
+    return parsedUrl.toString();
+  }
+
+  async fetchBookingUrl(url) {
+    let nextUrl = this.addLimitParam(url, 99);
+    const allData = [];
+
+    try {
+      while (nextUrl) {
+        const response = await this.httpClient.get(nextUrl);
+        const json = response.data;
+
+        if (Array.isArray(json && json.items)) {
+          allData.push(...json.items);
+        }
+
+        nextUrl = json && json.next ? json.next : null;
+      }
+
+      return allData;
+    } catch (error) {
+      this.logError(
+        "Errore durante il recupero delle disponibilita complete:",
+        error,
+      );
+      return [];
+    }
+  }
+
+  async fetchAPIUrlLimit(url, limit = 99) {
+    let nextUrl = this.addLimitParam(url, limit);
+    const allData = [];
+
+    try {
+      while (nextUrl) {
+        const response = await this.httpClient.get(nextUrl);
+        const json = response.data;
+
+        if (Array.isArray(json && json.data)) {
+          allData.push(...json.data);
+        }
+
+        nextUrl = json && json.next ? json.next : null;
+      }
+
+      return allData;
+    } catch (error) {
+      this.logError(
+        "Errore durante il recupero delle disponibilita complete:",
+        error,
+      );
+      return [];
+    }
+  }
+
+  async getBookingConfig(id = null) {
+    try {
+      let siteUrl = this.getSiteUrl();
+      if (!siteUrl) {
+        const tenantInfo = await this.getTenantInfo();
+        siteUrl = tenantInfo && tenantInfo.site_url ? tenantInfo.site_url : null;
+      }
+
+      if (!siteUrl) {
+        this.logWarn("Nessun site_url trovato, impossibile proseguire.");
+        return null;
+      }
+
+      const cleanedBaseUrl = siteUrl.replace(/\/$/, "");
+      const query = id ? `?id=${encodeURIComponent(id)}` : "";
+      const apiUrl = `${cleanedBaseUrl}/api/openapi/booking-config${query}`;
+
+      const response = await this.fetchBookingUrl(apiUrl);
+      return response;
+    } catch (error) {
+      this.logError("Errore in getBookingConfig:", error);
+      return null;
+    }
+  }
+
+  async getRatesLists(url, calendarId) {
+    const tenant = await this.getTenantInfo();
+
+    if (tenant && tenant.id) {
+      return this.postGraphql(
+        url,
+        "POST",
+        `query fetchList {
+       rooms(filter: {id:{ _eq: "${calendarId}"},tenant:{id:{_eq:"${tenant.id}"}}}) {
+    id
+    title
+    rates_list(filter:{status:{_eq:"published"}}) {
+      id
+      title
+      rates {
+        id
+        rate
+        title
+        amount_lower_limit
+        amount_upper_limit
+        hours_lower_limit
+        hours_upper_limit
+      }
+    }
+    }}`,
+      )
+        .then((result) => {
+          return result;
+        })
+        .catch((error) => {
+          this.logError("error getRatesLists", error);
+          return null;
+        });
+    }
+
+    return null;
+  }
+
+  async editFormProperties(instance, edits) {
+    if (!instance || typeof instance.getComponent !== "function") {
+      this.logError("[editFormProperties] Invalid instance:", instance);
+      return;
+    }
+
+    for (const [fullPath, changes] of Object.entries(edits)) {
+      const pathParts = fullPath.split(".");
+      const fieldKey = pathParts.pop();
+      let currentInstance = instance;
+
+      for (const part of pathParts) {
+        let comp;
+        try {
+          comp = currentInstance.getComponent(part);
+        } catch (error) {
+          this.logError("[editFormProperties:getComponent - nested]", part, error);
+          comp = null;
+        }
+
+        if (!comp || comp.type !== "form") {
+          currentInstance = null;
+          break;
+        }
+
+        if (!comp.subForm) {
+          currentInstance = null;
+          break;
+        }
+
+        if (typeof comp.subForm.ready === "function") {
+          try {
+            await comp.subForm.ready;
+          } catch (error) {
+            this.logError("[editFormProperties] subForm.ready failed:", part, error);
+            currentInstance = null;
+            break;
+          }
+        }
+
+        currentInstance = comp.subForm;
+      }
+
+      if (!currentInstance) {
+        continue;
+      }
+
+      let comp;
+      try {
+        comp = currentInstance.getComponent(fieldKey);
+      } catch (error) {
+        this.logError("[editFormProperties:getComponent - field]", fieldKey, error);
+        continue;
+      }
+
+      if (!comp) {
+        continue;
+      }
+
+      for (const [propPath, newVal] of Object.entries(changes)) {
+        try {
+          const parts = propPath.split(".");
+          let target = comp.component;
+
+          for (let i = 0; i < parts.length - 1; i += 1) {
+            if (!target[parts[i]]) {
+              target[parts[i]] = {};
+            }
+            target = target[parts[i]];
+          }
+
+          const last = parts[parts.length - 1];
+          if (last === "hidden") {
+            comp._hasCondition = newVal ? false : true;
+          }
+
+          if (target[last] !== newVal) {
+            target[last] = newVal;
+
+            if (typeof comp.redraw === "function") {
+              try {
+                comp.redraw();
+              } catch (error) {
+                this.logError("[editFormProperties:redraw]", fullPath, propPath, error);
+              }
+            }
+          }
+        } catch (error) {
+          this.logError(
+            "[editFormProperties:property assignment]",
+            fullPath,
+            propPath,
+            error,
+          );
+        }
+      }
+    }
+  }
+
+  checkResidences(data, residenceFields, requireAllResidences = false) {
+    if (!data) {
+      throw new Error("[checkResidences] Data object is missing.");
+    }
+
+    if (!data.residence_tenant) {
+      return false;
+    }
+
+    const tenantName = data.residence_tenant.toLowerCase();
+    const residenceMatchFn = requireAllResidences ? "every" : "some";
+
+    const isLocationInTenant = residenceFields[residenceMatchFn]((path) => {
+      const locality = (get(data, path, "") || "").toLowerCase().trim();
+      return locality !== "" && tenantName.includes(locality);
+    });
+
+    const COUNTRY_FIELDS = ["address_country", "country"];
+
+    const hasEmptyCountry = residenceFields.every((config) => {
+      const basePath = config.split(".").slice(0, -1).join(".");
+      return COUNTRY_FIELDS.every((field) => {
+        const value = get(data, `${basePath}.${field}`, "");
+        return typeof value === "string" && value.trim() === "";
+      });
+    });
+
+    return isLocationInTenant ? false : !hasEmptyCountry;
+  }
+
+  syncApplicantToBeneficiary(data, instance, applicantRequester) {
+    if (!data) {
+      throw new Error("[syncApplicantToBeneficiary] Data object is missing.");
+    }
+
+    if (!instance || typeof instance.getComponent !== "function") {
+      this.logError("[syncApplicantToBeneficiary] Invalid instance:", instance);
+      return;
+    }
+
+    const jsonString = JSON.stringify(data.applicant);
+    let hash = 0;
+    for (let i = 0; i < jsonString.length; i += 1) {
+      const char = jsonString.charCodeAt(i);
+      hash = (hash << 5) - hash + char;
+      hash &= hash;
+    }
+    hash = hash.toString(16);
+
+    if (applicantRequester && hash !== data.applicant_hash) {
+      const sub = Object.assign({}, instance.calculatedValue);
+
+      sub.data.given_name = data.applicant.data.completename.data.name;
+      sub.data.family_name = data.applicant.data.completename.data.surname;
+
+      if (data.applicant.data.Born && data.applicant.data.Born.data) {
+        sub.data.birth_place = data.applicant.data.Born.data.place_of_birth;
+        sub.data.birth_date = data.applicant.data.Born.data.natoAIl;
+      }
+
+      if (data.applicant.data.gender && data.applicant.data.gender.data) {
+        sub.data.gender = data.applicant.data.gender.data.gender;
+      }
+
+      if (data.applicant.data.fiscal_code && data.applicant.data.fiscal_code.data) {
+        sub.data.tax_id = data.applicant.data.fiscal_code.data.fiscal_code;
+      }
+
+      if (data.applicant.data.address && data.applicant.data.address.data) {
+        if (!sub.data.address) {
+          sub.data.address = { data: {} };
+        }
+
+        sub.data.address.data.street_address = data.applicant.data.address.data.address;
+        sub.data.address.data.address_number =
+          data.applicant.data.address.data.house_number;
+        sub.data.address.data.address_locality =
+          data.applicant.data.address.data.municipality;
+        sub.data.address.data.postal_code = data.applicant.data.address.data.postal_code;
+        sub.data.address.data.address_country = data.applicant.data.address.data.country;
+      }
+
+      sub.data.nationality = data.beneficiary.data.nationality;
+      sub.data.nation = data.beneficiary.data.nation;
+
+      instance.setValue(sub);
+      data.applicant_hash = hash;
+    } else if (!applicantRequester && data.applicant_hash !== "") {
+      instance.setValue(instance.defaultValue);
+      data.applicant_hash = "";
+    }
+  }
+}
+
+function createFormioHelper(options = {}) {
+  return new FormioHelper(options);
+}
+
+module.exports = FormioHelper;
+module.exports.FormioHelper = FormioHelper;
+module.exports.createFormioHelper = createFormioHelper;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@opencitylabs/formio-sdk",
+  "version": "1.0.0",
+  "description": "Node/browser SDK helper for Form.io APIs",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node -e \"require('./index.js')\""
+  },
+  "keywords": [
+    "formio",
+    "sdk",
+    "node",
+    "api"
+  ],
+  "author": "OpencityLabs",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.13.5",
+    "lodash.get": "^4.4.2"
+  }
+}