@hamak/smart-data-dico 1.10.1 → 1.12.0

package/README.md

@@ -292,6 +292,44 @@ cd frontend && npm run dev   # port 3000
 
 In dev, the backend serves the bundled sample project at `samples/eshop/` (three packages: `order-service`, `product-service`, `user-service`). Override with `DATA_DIR=/path/to/your/project npm run dev` to point at your own data.
 
+### Option C — Restricted networks (no npm registry for this package, or no git)
+
+When the npm registry copy of the package is unavailable, install it from git or
+from a prebuilt release tarball. These do **not** require the package to be on a
+registry; the lower options additionally avoid needing the `git` binary.
+
+**C1 — Prebuilt tarball over `curl` (no git, no build, fully offline-capable).**
+Each release attaches a **self-contained** tarball (esbuild-bundled backend, no
+runtime `node_modules`; Node ≥ 18). Download and install it directly:
+
+```bash
+curl -fL -o smart-data-dico.tgz \
+  https://github.com/amah/smart-data-dico/releases/download/v1.11.0/hamak-smart-data-dico-1.11.0.tgz
+npm install -g ./smart-data-dico.tgz
+smart-data-dico --data-dir /path/to/your/project
+```
+
+For a fully air-gapped machine, download the `.tgz` on a connected host, copy it
+across, and run the `npm install -g ./…tgz` step there — it needs no network.
+
+**C2 — Build from git with the helper script.** Clones a pinned ref, installs
+deps (root/frontend/backend), builds both bundles, packs a tarball, and installs
+the CLI globally:
+
+```bash
+scripts/install-from-git.sh                 # build v1.11.0, install globally
+scripts/install-from-git.sh --pack-only     # just produce the tarball (prints its path)
+```
+
+Add `--archive` (auto-enabled when `git` is absent) to fetch the source via
+`curl`/`wget` instead of cloning. Useful env/flags: `SDD_REF` (tag/branch/commit),
+`SDD_REPO_URL` (internal mirror or SSH), `-d` (work dir). Run `scripts/install-from-git.sh --help`
+for the full list.
+
+> Note: C2 still pulls build **dependencies** from whichever npm registry / proxy
+> `npm` is configured to use. If even that is blocked, use **C1** — build the
+> tarball once on a connected machine (`--pack-only`) and install the artifact offline.
+
 ### Option C — Docker
 
 ```bash

package/backend/dist/server.mjs

@@ -156400,6 +156400,7 @@ init_EntitySchema();
 init_logger();
 init_StorageBackendToken();
 init_types();
+var DOMAIN_KINDS = /* @__PURE__ */ new Set(["enum", "codelist", "reference"]);
 var DICT_WS2 = wsId("dictionaries");
 var CONFIG_PATH = pathOf("dico.config.json");
 var STANDARD_TYPES = new Set(Object.values(AttributeType));
@@ -156454,6 +156455,7 @@ function validateDerivedTypes(types) {
     if (!t.basedOn || typeof t.basedOn !== "string") {
       errors.push(`Derived type '${t.name}' must declare a \`basedOn\``);
     }
+    if (t.domain) errors.push(...validateDomain(t.name, t.domain));
   }
   for (const t of types) {
     if (!t?.name || !t?.basedOn) continue;
@@ -156476,6 +156478,42 @@ function validateDerivedTypes(types) {
   return errors;
 }
 __name(validateDerivedTypes, "validateDerivedTypes");
+function validateDomain(typeName, domain2) {
+  const errors = [];
+  if (!DOMAIN_KINDS.has(domain2.kind)) {
+    errors.push(`Derived type '${typeName}' has invalid domain kind '${domain2.kind}'`);
+    return errors;
+  }
+  const hasValues = Array.isArray(domain2.values) && domain2.values.length > 0;
+  const hasSource = typeof domain2.source === "string" && domain2.source.trim().length > 0;
+  if (domain2.kind === "enum") {
+    if (!hasValues) errors.push(`Enum domain '${typeName}' must list at least one value`);
+    if (hasSource) errors.push(`Enum domain '${typeName}' must not declare a \`source\``);
+  } else if (domain2.kind === "codelist") {
+    if (!hasSource) errors.push(`Codelist domain '${typeName}' must declare a \`source\` name`);
+  } else if (domain2.kind === "reference") {
+    if (!hasSource) errors.push(`Reference domain '${typeName}' must declare a \`source\` name`);
+    if (hasValues) errors.push(`Reference domain '${typeName}' must not carry inline \`values\` (they come from the source)`);
+  }
+  return errors;
+}
+__name(validateDomain, "validateDomain");
+function resolveDomain(typeName, derivedTypes) {
+  if (STANDARD_TYPES.has(typeName)) return null;
+  const byName = new Map(derivedTypes.map((t) => [t.name, t]));
+  const visited = /* @__PURE__ */ new Set();
+  let cursor = typeName;
+  while (!STANDARD_TYPES.has(cursor)) {
+    if (visited.has(cursor)) return null;
+    visited.add(cursor);
+    const dt = byName.get(cursor);
+    if (!dt) return null;
+    if (dt.domain) return dt.domain;
+    cursor = dt.basedOn;
+  }
+  return null;
+}
+__name(resolveDomain, "resolveDomain");
 function resolveAttributeType(typeName, derivedTypes) {
   if (STANDARD_TYPES.has(typeName)) {
     return { baseType: typeName, validation: {} };
@@ -160361,8 +160399,21 @@ var ExportService = class {
       description: dt.description || void 0
     };
     this.applyValidationToSchema(schema, resolved.validation);
+    this.applyDomainToSchema(schema, resolveDomain(dt.name, all));
     return schema;
   }
+  /**
+   * Project a {@link ValueDomain} into JSON Schema. enum/codelist values become
+   * a standard `enum`; the kind and (for codelist/reference) the source are kept
+   * as `x-domain` / `x-source` extension keywords so consumers can distinguish
+   * a static code list from a live referential source.
+   */
+  applyDomainToSchema(schema, domain2) {
+    if (!domain2) return;
+    schema["x-domain"] = domain2.kind;
+    if (domain2.source) schema["x-source"] = domain2.source;
+    if (Array.isArray(domain2.values) && domain2.values.length > 0) schema.enum = domain2.values;
+  }
   attributeToJsonSchema(attr, derivedTypes = []) {
     if (!Object.values(AttributeType).includes(attr.type)) {
       const resolved = resolveAttributeType(attr.type, derivedTypes);

package/backend/dist/validate.mjs

@@ -10037,6 +10037,7 @@ var FLOW_STEP_KINDS = /* @__PURE__ */ new Set([
 ]);
 
 // backend/src/services/dicoConfigService.ts
+var DOMAIN_KINDS = /* @__PURE__ */ new Set(["enum", "codelist", "reference"]);
 var DICT_WS = wsId("dictionaries");
 var CONFIG_PATH = pathOf("dico.config.json");
 var STANDARD_TYPES = new Set(Object.values(AttributeType));
@@ -10059,6 +10060,7 @@ function validateDerivedTypes(types) {
     if (!t.basedOn || typeof t.basedOn !== "string") {
       errors.push(`Derived type '${t.name}' must declare a \`basedOn\``);
     }
+    if (t.domain) errors.push(...validateDomain(t.name, t.domain));
   }
   for (const t of types) {
     if (!t?.name || !t?.basedOn) continue;
@@ -10081,6 +10083,26 @@ function validateDerivedTypes(types) {
   return errors;
 }
 __name(validateDerivedTypes, "validateDerivedTypes");
+function validateDomain(typeName, domain) {
+  const errors = [];
+  if (!DOMAIN_KINDS.has(domain.kind)) {
+    errors.push(`Derived type '${typeName}' has invalid domain kind '${domain.kind}'`);
+    return errors;
+  }
+  const hasValues = Array.isArray(domain.values) && domain.values.length > 0;
+  const hasSource = typeof domain.source === "string" && domain.source.trim().length > 0;
+  if (domain.kind === "enum") {
+    if (!hasValues) errors.push(`Enum domain '${typeName}' must list at least one value`);
+    if (hasSource) errors.push(`Enum domain '${typeName}' must not declare a \`source\``);
+  } else if (domain.kind === "codelist") {
+    if (!hasSource) errors.push(`Codelist domain '${typeName}' must declare a \`source\` name`);
+  } else if (domain.kind === "reference") {
+    if (!hasSource) errors.push(`Reference domain '${typeName}' must declare a \`source\` name`);
+    if (hasValues) errors.push(`Reference domain '${typeName}' must not carry inline \`values\` (they come from the source)`);
+  }
+  return errors;
+}
+__name(validateDomain, "validateDomain");
 
 // backend/src/models/ormVocabulary.ts
 var ORM_VOCABULARY = {