feat(data-plane): add provider contracts and ontology delivery

2026-07-16 02:23:34 +03:00
parent e527812826
commit 569b8762e6
84 changed files with 11170 additions and 70 deletions
@@ -0,0 +1,118 @@
+const IDENTIFIER = /^[a-z][a-z0-9._:-]{2,127}$/;
+const SEMVER = /^\d+\.\d+\.\d+(?:[-+][a-z0-9.-]+)?$/i;
+const DELIVERY_MODES = new Set(["snapshot", "snapshot+patch", "query"]);
+const HISTORY_MODES = new Set(["none", "all", "sampled"]);
+const DEFINITION_KEYS = new Set([
+  "id", "version", "ontologyRevision", "deliveryMode", "semanticTypes", "fields", "history",
+]);
+const HISTORY_KEYS = new Set(["mode", "intervalMs", "retentionDays", "strategy"]);
+
+export function normalizeDataProductDefinition(value) {
+  if (!isPlainObject(value) || !hasOnlyKeys(value, DEFINITION_KEYS)) {
+    throw policyError("data_product_definition_invalid");
+  }
+  const id = identifier(value.id);
+  const version = string(value.version);
+  const ontologyRevision = identifier(value.ontologyRevision);
+  const deliveryMode = string(value.deliveryMode);
+  const semanticTypes = identifierSet(
+    value.semanticTypes,
+    "data_product_definition_semantic_types_invalid",
+    "data_product_definition_semantic_types_duplicate",
+  );
+  const fields = identifierSet(
+    value.fields,
+    "data_product_definition_fields_invalid",
+    "data_product_definition_fields_duplicate",
+  );
+  if (!id || !SEMVER.test(version) || !ontologyRevision || !DELIVERY_MODES.has(deliveryMode)) {
+    throw policyError("data_product_definition_identity_invalid");
+  }
+  if (!semanticTypes.length || !fields.length) throw policyError("data_product_definition_shape_invalid");
+
+  const history = normalizeHistoryPolicy(value.history);
+  return Object.freeze({ id, version, ontologyRevision, deliveryMode, semanticTypes, fields, history });
+}
+
+export function normalizeHistoryPolicy(value = { mode: "none" }) {
+  if (!isPlainObject(value) || !hasOnlyKeys(value, HISTORY_KEYS)) throw policyError("history_policy_invalid");
+  const mode = string(value.mode);
+  if (!HISTORY_MODES.has(mode)) throw policyError("history_policy_mode_invalid");
+  const retentionDays = integer(value.retentionDays, mode === "none" ? 1 : 90, 1, 3650);
+  if (mode === "none") {
+    if (value.intervalMs !== undefined || value.strategy !== undefined) throw policyError("history_policy_none_has_sampling_fields");
+    return Object.freeze({ mode, retentionDays });
+  }
+  if (mode === "all") {
+    if (value.intervalMs !== undefined || value.strategy !== undefined) throw policyError("history_policy_all_has_sampling_fields");
+    return Object.freeze({ mode, retentionDays });
+  }
+
+  const intervalMs = integer(value.intervalMs, 60_000, 1_000, 24 * 60 * 60 * 1000);
+  const strategy = string(value.strategy || "latest-per-entity-per-bucket");
+  if (strategy !== "latest-per-entity-per-bucket") throw policyError("history_policy_strategy_invalid");
+  return Object.freeze({ mode, intervalMs, strategy, retentionDays });
+}
+
+export function safeDataProductDefinition(row) {
+  return {
+    id: row.id,
+    version: row.version,
+    ontologyRevision: row.ontologyRevision,
+    deliveryMode: row.deliveryMode,
+    semanticTypes: array(row.semanticTypes),
+    fields: array(row.fields),
+    history: isPlainObject(row.historyPolicy) ? row.historyPolicy : {},
+    active: row.active === true,
+    createdAt: iso(row.createdAt),
+    updatedAt: iso(row.updatedAt),
+  };
+}
+
+function policyError(code) {
+  return Object.assign(new Error(code), { status: 400, code });
+}
+
+function identifier(value) {
+  const normalized = string(value);
+  return IDENTIFIER.test(normalized) ? normalized : "";
+}
+
+function identifierSet(value, invalidCode, duplicateCode) {
+  if (!Array.isArray(value)) throw policyError(invalidCode);
+
+  const normalized = value.map((entry) => {
+    const result = identifier(entry);
+    if (!result) throw policyError(invalidCode);
+    return result;
+  });
+  if (new Set(normalized).size !== normalized.length) throw policyError(duplicateCode);
+
+  return Object.freeze(normalized.sort());
+}
+
+function integer(value, fallback, min, max) {
+  const number = value === undefined ? fallback : Number(value);
+  if (!Number.isInteger(number) || number < min || number > max) throw policyError("history_policy_number_invalid");
+  return number;
+}
+
+function string(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+
+function iso(value) {
+  return value ? new Date(value).toISOString() : undefined;
+}
+
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasOnlyKeys(value, allowed) {
+  return Object.keys(value).every((key) => allowed.has(key));
+}