@reventlessdev/reventless-spec 3.0.0-alpha.61

package/src/components/DcbTag.res.mjs

@@ -0,0 +1,869 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Primitive_int from "@rescript/runtime/lib/es6/Primitive_int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js";
+
+let tagSchema = S.schema(s => ({
+  key: s.m(S.string),
+  value: s.m(S.string)
+}));
+
+let dcbTagId = S.Metadata.Id.make("dcb", "tag");
+
+let dcbPartitionTagId = S.Metadata.Id.make("dcb", "partitionTag");
+
+let dcbCrossPartitionId = S.Metadata.Id.make("dcb", "crossPartition");
+
+let dcbCompositePartitionMemberId = S.Metadata.Id.make("dcb", "compositePartitionMember");
+
+let dcbTagKeyOverrideId = S.Metadata.Id.make("dcb", "tagKeyOverride");
+
+let string = S.Metadata.set(S.string, dcbTagId, true);
+
+function stringForKey(key) {
+  return S.Metadata.set(S.Metadata.set(S.string, dcbTagId, true), dcbTagKeyOverrideId, key);
+}
+
+let int = S.Metadata.set(S.int, dcbTagId, true);
+
+let partition = S.Metadata.set(S.Metadata.set(S.string, dcbTagId, true), dcbPartitionTagId, true);
+
+let crossPartition = S.Metadata.set(S.Metadata.set(S.string, dcbTagId, true), dcbCrossPartitionId, true);
+
+function compositePartitionMember(position, sepOpt) {
+  let sep = sepOpt !== undefined ? sepOpt : "/";
+  return S.Metadata.set(S.Metadata.set(S.string, dcbTagId, true), dcbCompositePartitionMemberId, {
+    position: position,
+    sep: sep
+  });
+}
+
+function isCompositePartitionMember(fieldSchema) {
+  return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbCompositePartitionMemberId));
+}
+
+function isTagged(fieldSchema) {
+  return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbTagId));
+}
+
+function isTaggedArray(fieldSchema) {
+  if (fieldSchema.type !== "array") {
+    return false;
+  }
+  let itemSchema = fieldSchema.additionalItems;
+  if (itemSchema === "strip" || itemSchema === "strict") {
+    return false;
+  } else {
+    return isTagged(itemSchema);
+  }
+}
+
+function isPartitionTag(fieldSchema) {
+  return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbPartitionTagId));
+}
+
+function isCrossPartitionTag(fieldSchema) {
+  return Stdlib_Option.isSome(S.Metadata.get(fieldSchema, dcbCrossPartitionId));
+}
+
+function isCrossPartitionTaggedArray(fieldSchema) {
+  if (fieldSchema.type !== "array") {
+    return false;
+  }
+  let itemSchema = fieldSchema.additionalItems;
+  if (itemSchema === "strip" || itemSchema === "strict") {
+    return false;
+  } else {
+    return isCrossPartitionTag(itemSchema);
+  }
+}
+
+function resolveTagKey(fieldName, fieldSchema) {
+  return Stdlib_Option.getOr(S.Metadata.get(fieldSchema, dcbTagKeyOverrideId), fieldName);
+}
+
+function resolveArrayTagKey(fieldName, fieldSchema) {
+  if (fieldSchema.type !== "array") {
+    return fieldName;
+  }
+  let itemSchema = fieldSchema.additionalItems;
+  if (itemSchema === "strip" || itemSchema === "strict") {
+    return fieldName;
+  } else {
+    return Stdlib_Option.getOr(S.Metadata.get(itemSchema, dcbTagKeyOverrideId), fieldName);
+  }
+}
+
+function jsonValueToString(json) {
+  switch (typeof json) {
+    case "boolean" :
+      if (json) {
+        return "true";
+      } else {
+        return "false";
+      }
+    case "string" :
+      return json;
+    case "number" :
+      return json.toString();
+    default:
+      return JSON.stringify(json);
+  }
+}
+
+function extractTagsFromProperties(properties, jsonDict) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldSchema = param[1];
+    let fieldName = param[0];
+    if (isTagged(fieldSchema)) {
+      return Stdlib_Option.map(jsonDict[fieldName], jsonValue => ({
+        key: resolveTagKey(fieldName, fieldSchema),
+        value: jsonValueToString(jsonValue)
+      }));
+    }
+  });
+}
+
+function extractTagsFromJson(schema, json) {
+  switch (schema.type) {
+    case "object" :
+      let jsonDict = Stdlib_JSON.Decode.object(json);
+      if (jsonDict !== undefined) {
+        return extractTagsFromProperties(schema.properties, jsonDict);
+      } else {
+        return [];
+      }
+    case "union" :
+      let jsonDict$1 = Stdlib_JSON.Decode.object(json);
+      if (jsonDict$1 === undefined) {
+        return [];
+      }
+      let jsonTag = Stdlib_Option.flatMap(jsonDict$1["TAG"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      });
+      return Stdlib_Array.reduce(schema.anyOf, [], (acc, variantSchema) => {
+        if (acc.length !== 0) {
+          return acc;
+        }
+        if (variantSchema.type !== "object") {
+          return [];
+        }
+        let variantTag = Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+          let match = item.schema;
+          if (match.type !== "string") {
+            return;
+          }
+          let $$const = match.const;
+          if ($$const !== undefined) {
+            return $$const;
+          }
+        });
+        if (Primitive_object.equal(variantTag, jsonTag)) {
+          return extractTagsFromProperties(variantSchema.properties, jsonDict$1);
+        } else {
+          return [];
+        }
+      });
+    default:
+      return [];
+  }
+}
+
+function extractTags(schema, value) {
+  let json = JSON.parse(Stdlib_Option.getOrThrow(JSON.stringify(value), undefined));
+  return extractTagsFromJson(schema, json);
+}
+
+function extractVariantNames(schema) {
+  switch (schema.type) {
+    case "object" :
+      return Stdlib_Option.getOr(Stdlib_Option.flatMap(schema.items.find(item => item.location === "TAG"), item => {
+        let match = item.schema;
+        if (match.type !== "string") {
+          return;
+        }
+        let $$const = match.const;
+        if ($$const !== undefined) {
+          return [$$const];
+        }
+      }), []);
+    case "union" :
+      return Stdlib_Array.filterMap(schema.anyOf, variantSchema => {
+        if (variantSchema.type === "object") {
+          return Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+            let match = item.schema;
+            if (match.type !== "string") {
+              return;
+            }
+            let $$const = match.const;
+            if ($$const !== undefined) {
+              return $$const;
+            }
+          });
+        }
+      });
+    default:
+      return [];
+  }
+}
+
+function extractAllVariantNames(schema) {
+  switch (schema.type) {
+    case "string" :
+      let name = schema.const;
+      if (name !== undefined) {
+        return [name];
+      } else {
+        return [];
+      }
+    case "object" :
+      return Stdlib_Option.getOr(Stdlib_Option.flatMap(schema.items.find(item => item.location === "TAG"), item => {
+        let match = item.schema;
+        if (match.type !== "string") {
+          return;
+        }
+        let $$const = match.const;
+        if ($$const !== undefined) {
+          return [$$const];
+        }
+      }), []);
+    case "union" :
+      return Stdlib_Array.filterMap(schema.anyOf, variantSchema => {
+        switch (variantSchema.type) {
+          case "string" :
+            let $$const = variantSchema.const;
+            if ($$const !== undefined) {
+              return $$const;
+            } else {
+              return;
+            }
+          case "object" :
+            return Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+              let match = item.schema;
+              if (match.type !== "string") {
+                return;
+              }
+              let $$const = match.const;
+              if ($$const !== undefined) {
+                return $$const;
+              }
+            });
+          default:
+            return;
+        }
+      });
+    default:
+      return [];
+  }
+}
+
+function isVariantPayloadBearing(schema, name) {
+  let names = extractAllVariantNames(schema);
+  if (!names.includes(name)) {
+    return false;
+  }
+  switch (schema.type) {
+    case "object" :
+      return Stdlib_Option.getOr(Stdlib_Option.flatMap(schema.items.find(item => item.location === "TAG"), item => {
+        let match = item.schema;
+        if (match.type !== "string") {
+          return;
+        }
+        let $$const = match.const;
+        if ($$const !== undefined) {
+          return $$const === name;
+        }
+      }), false);
+    case "union" :
+      return schema.anyOf.some(variantSchema => {
+        if (variantSchema.type === "object") {
+          return Stdlib_Option.getOr(Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+            let match = item.schema;
+            if (match.type !== "string") {
+              return;
+            }
+            let $$const = match.const;
+            if ($$const !== undefined) {
+              return $$const === name;
+            }
+          }), false);
+        } else {
+          return false;
+        }
+      });
+    default:
+      return false;
+  }
+}
+
+function extractTagsFromPropertiesExpanded(properties, jsonDict) {
+  return Object.entries(properties).flatMap(param => {
+    let fieldSchema = param[1];
+    let fieldName = param[0];
+    if (isTagged(fieldSchema)) {
+      let jsonValue = jsonDict[fieldName];
+      if (jsonValue !== undefined) {
+        return [{
+            key: resolveTagKey(fieldName, fieldSchema),
+            value: jsonValueToString(jsonValue)
+          }];
+      } else {
+        return [];
+      }
+    }
+    if (!isTaggedArray(fieldSchema)) {
+      return [];
+    }
+    let match = jsonDict[fieldName];
+    if (match === undefined) {
+      return [];
+    }
+    if (!Array.isArray(match)) {
+      return [];
+    }
+    let tagKey = resolveArrayTagKey(fieldName, fieldSchema);
+    return match.map(element => ({
+      key: tagKey,
+      value: jsonValueToString(element)
+    }));
+  });
+}
+
+function extractTagsFromJsonExpanded(schema, json) {
+  switch (schema.type) {
+    case "object" :
+      let jsonDict = Stdlib_JSON.Decode.object(json);
+      if (jsonDict !== undefined) {
+        return extractTagsFromPropertiesExpanded(schema.properties, jsonDict);
+      } else {
+        return [];
+      }
+    case "union" :
+      let jsonDict$1 = Stdlib_JSON.Decode.object(json);
+      if (jsonDict$1 === undefined) {
+        return [];
+      }
+      let jsonTag = Stdlib_Option.flatMap(jsonDict$1["TAG"], j => {
+        if (typeof j === "string") {
+          return j;
+        }
+      });
+      return Stdlib_Array.reduce(schema.anyOf, [], (acc, variantSchema) => {
+        if (acc.length !== 0) {
+          return acc;
+        }
+        if (variantSchema.type !== "object") {
+          return [];
+        }
+        let variantTag = Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+          let match = item.schema;
+          if (match.type !== "string") {
+            return;
+          }
+          let $$const = match.const;
+          if ($$const !== undefined) {
+            return $$const;
+          }
+        });
+        if (Primitive_object.equal(variantTag, jsonTag)) {
+          return extractTagsFromPropertiesExpanded(variantSchema.properties, jsonDict$1);
+        } else {
+          return [];
+        }
+      });
+    default:
+      return [];
+  }
+}
+
+function extractTagsExpanded(schema, value) {
+  let json = JSON.parse(Stdlib_Option.getOrThrow(JSON.stringify(value), undefined));
+  return extractTagsFromJsonExpanded(schema, json);
+}
+
+function hasTaggedArrayFields(schema) {
+  switch (schema.type) {
+    case "object" :
+      return Object.entries(schema.properties).some(param => isTaggedArray(param[1]));
+    case "union" :
+      return schema.anyOf.some(variantSchema => {
+        if (variantSchema.type === "object") {
+          return Object.entries(variantSchema.properties).some(param => isTaggedArray(param[1]));
+        } else {
+          return false;
+        }
+      });
+    default:
+      return false;
+  }
+}
+
+function tagKeysOfProperties(properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldSchema = param[1];
+    let fieldName = param[0];
+    if (isTagged(fieldSchema)) {
+      return resolveTagKey(fieldName, fieldSchema);
+    } else if (isTaggedArray(fieldSchema)) {
+      return resolveArrayTagKey(fieldName, fieldSchema);
+    } else {
+      return;
+    }
+  });
+}
+
+function extractTagKeysByEventType(schema) {
+  let result = {};
+  let addVariant = variantSchema => {
+    if (variantSchema.type !== "object") {
+      return;
+    }
+    let properties = variantSchema.properties;
+    Stdlib_Option.forEach(Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+      let match = item.schema;
+      if (match.type !== "string") {
+        return;
+      }
+      let $$const = match.const;
+      if ($$const !== undefined) {
+        return $$const;
+      }
+    }), eventType => {
+      result[eventType] = tagKeysOfProperties(properties);
+    });
+  };
+  switch (schema.type) {
+    case "object" :
+      addVariant(schema);
+      break;
+    case "union" :
+      schema.anyOf.forEach(addVariant);
+      break;
+  }
+  return result;
+}
+
+function mergeTagKeysByEventType(maps) {
+  let merged = {};
+  maps.forEach(m => {
+    Object.entries(m).forEach(param => {
+      merged[param[0]] = param[1];
+    });
+  });
+  return merged;
+}
+
+function narrowEventTypesForTags(eventTypes, tags, tagKeysByEventType) {
+  return eventTypes.filter(eventType => {
+    let producedKeys = tagKeysByEventType[eventType];
+    if (producedKeys !== undefined) {
+      return tags.every(tag => producedKeys.includes(tag.key));
+    } else {
+      return true;
+    }
+  });
+}
+
+function buildQueryFromCommand(eventTypes, schema, value, tagKeysByEventTypeOpt, crossPartitionTagKeysOpt) {
+  let tagKeysByEventType = tagKeysByEventTypeOpt !== undefined ? tagKeysByEventTypeOpt : ({});
+  let crossPartitionTagKeys = crossPartitionTagKeysOpt !== undefined ? crossPartitionTagKeysOpt : [];
+  if (hasTaggedArrayFields(schema)) {
+    let tags = extractTagsExpanded(schema, value);
+    return tags.map(tag => {
+      let clauseTags = [{
+          key: tag.key,
+          value: tag.value
+        }];
+      return {
+        eventTypes: narrowEventTypesForTags(eventTypes, clauseTags, tagKeysByEventType),
+        tags: clauseTags
+      };
+    });
+  }
+  let tags$1 = extractTags(schema, value);
+  let hasCrossPartition = tags$1.some(tag => crossPartitionTagKeys.includes(tag.key));
+  if (hasCrossPartition && tags$1.length > 1) {
+    return tags$1.map(tag => {
+      let clauseTags = [{
+          key: tag.key,
+          value: tag.value
+        }];
+      return {
+        eventTypes: narrowEventTypesForTags(eventTypes, clauseTags, tagKeysByEventType),
+        tags: clauseTags
+      };
+    });
+  } else {
+    return [{
+        eventTypes: narrowEventTypesForTags(eventTypes, tags$1, tagKeysByEventType),
+        tags: tags$1
+      }];
+  }
+}
+
+function extractTaggedFields(schema) {
+  switch (schema.type) {
+    case "object" :
+      return Stdlib_Array.filterMap(Object.entries(schema.properties), param => {
+        if (isTagged(param[1])) {
+          return param[0];
+        }
+      }).toSorted(Primitive_string.compare);
+    case "union" :
+      let allFields = schema.anyOf.flatMap(variantSchema => {
+        if (variantSchema.type === "object") {
+          return Stdlib_Array.filterMap(Object.entries(variantSchema.properties), param => {
+            if (isTagged(param[1])) {
+              return param[0];
+            }
+          });
+        } else {
+          return [];
+        }
+      });
+      let fieldSet = new Set();
+      allFields.forEach(field => {
+        fieldSet.add(field);
+      });
+      return Array.from(fieldSet.values()).toSorted(Primitive_string.compare);
+    default:
+      return [];
+  }
+}
+
+function crossPartitionKeysOfProperties(properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let fieldSchema = param[1];
+    let fieldName = param[0];
+    if (isTagged(fieldSchema) && isCrossPartitionTag(fieldSchema)) {
+      return resolveTagKey(fieldName, fieldSchema);
+    } else if (isCrossPartitionTaggedArray(fieldSchema)) {
+      return resolveArrayTagKey(fieldName, fieldSchema);
+    } else {
+      return;
+    }
+  });
+}
+
+function extractCrossPartitionTagKeys(schema) {
+  let keys;
+  switch (schema.type) {
+    case "object" :
+      keys = crossPartitionKeysOfProperties(schema.properties);
+      break;
+    case "union" :
+      keys = schema.anyOf.flatMap(variantSchema => {
+        if (variantSchema.type === "object") {
+          return crossPartitionKeysOfProperties(variantSchema.properties);
+        } else {
+          return [];
+        }
+      });
+      break;
+    default:
+      keys = [];
+  }
+  let seen = new Set();
+  keys.forEach(k => {
+    seen.add(k);
+  });
+  return Array.from(seen.values()).toSorted(Primitive_string.compare);
+}
+
+function extractPartitionTagFields(schema) {
+  switch (schema.type) {
+    case "object" :
+      return Stdlib_Array.filterMap(Object.entries(schema.properties), param => {
+        if (isPartitionTag(param[1])) {
+          return param[0];
+        }
+      });
+    case "union" :
+      let allFields = schema.anyOf.flatMap(variantSchema => {
+        if (variantSchema.type === "object") {
+          return Stdlib_Array.filterMap(Object.entries(variantSchema.properties), param => {
+            if (isPartitionTag(param[1])) {
+              return param[0];
+            }
+          });
+        } else {
+          return [];
+        }
+      });
+      let fieldSet = new Set();
+      allFields.forEach(field => {
+        fieldSet.add(field);
+      });
+      return Array.from(fieldSet.values());
+    default:
+      return [];
+  }
+}
+
+function hasMultiTagVariant(schema) {
+  switch (schema.type) {
+    case "object" :
+      let tagCount = Object.entries(schema.properties).filter(param => isTagged(param[1])).length;
+      return tagCount > 1;
+    case "union" :
+      return schema.anyOf.some(variantSchema => {
+        if (variantSchema.type !== "object") {
+          return false;
+        }
+        let tagCount = Object.entries(variantSchema.properties).filter(param => isTagged(param[1])).length;
+        return tagCount > 1;
+      });
+    default:
+      return false;
+  }
+}
+
+function findMultiTagVariantNames(schema) {
+  let variantName = variantSchema => {
+    if (variantSchema.type !== "object") {
+      return;
+    }
+    let tagCount = Object.entries(variantSchema.properties).filter(param => isTagged(param[1])).length;
+    if (tagCount > 1) {
+      return Stdlib_Option.getOr(Stdlib_Option.flatMap(variantSchema.items.find(item => item.location === "TAG"), item => {
+        let match = item.schema;
+        if (match.type !== "string") {
+          return;
+        }
+        let $$const = match.const;
+        if ($$const !== undefined) {
+          return $$const;
+        }
+      }), "(unknown)");
+    }
+  };
+  if (schema.type === "union") {
+    return Stdlib_Array.filterMap(schema.anyOf, variantName);
+  }
+  let name = variantName(schema);
+  if (name !== undefined) {
+    return [name];
+  } else {
+    return [];
+  }
+}
+
+function extractCompositePartitionFieldsFromProperties(properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    let meta = S.Metadata.get(param[1], dcbCompositePartitionMemberId);
+    if (meta !== undefined) {
+      return {
+        name: param[0],
+        position: meta.position,
+        sep: meta.sep
+      };
+    }
+  }).toSorted((a, b) => Primitive_int.compare(a.position, b.position));
+}
+
+function extractCompositePartitionFields(schema) {
+  let seen = new Set();
+  let collect = properties => extractCompositePartitionFieldsFromProperties(properties).filter(info => {
+    if (seen.has(info.name)) {
+      return false;
+    } else {
+      seen.add(info.name);
+      return true;
+    }
+  });
+  switch (schema.type) {
+    case "object" :
+      return collect(schema.properties);
+    case "union" :
+      return schema.anyOf.flatMap(variantSchema => {
+        if (variantSchema.type === "object") {
+          return collect(variantSchema.properties);
+        } else {
+          return [];
+        }
+      });
+    default:
+      return [];
+  }
+}
+
+function getCompositePartitionKeyValue(tags, spec) {
+  return spec.keys.map((fieldName, i) => {
+    let v = Stdlib_Option.getOr(Stdlib_Array.findMap(tags, t => {
+      if (t.key === fieldName) {
+        return t.value;
+      }
+    }), "");
+    if (i === 0) {
+      return v;
+    } else {
+      return spec.seps[i - 1 | 0] + v;
+    }
+  }).join("");
+}
+
+function derivePartitionTag(namedSchemas) {
+  let schemas = namedSchemas.map(param => param[2]);
+  let seen = new Set();
+  let allCompositeFields = schemas.flatMap(extractCompositePartitionFields).filter(info => {
+    if (seen.has(info.name)) {
+      return false;
+    } else {
+      seen.add(info.name);
+      return true;
+    }
+  });
+  let hasComposite = allCompositeFields.length !== 0;
+  let seen$1 = new Set();
+  let allPartitionFields = schemas.flatMap(extractPartitionTagFields).filter(f => {
+    if (seen$1.has(f)) {
+      return false;
+    } else {
+      seen$1.add(f);
+      return true;
+    }
+  });
+  if (hasComposite && allPartitionFields.length !== 0) {
+    Stdlib_JsError.throwWithMessage(`DCB spec mixes @compositePartitionTag and @partitionTag — use one strategy per schema`);
+  }
+  if (hasComposite) {
+    if (allCompositeFields.length < 2) {
+      Stdlib_JsError.throwWithMessage(`@compositePartitionTag requires at least 2 annotated fields — only ` + allCompositeFields.length.toString() + ` found`);
+    }
+    let sorted = allCompositeFields.toSorted((a, b) => Primitive_int.compare(a.position, b.position));
+    let keys = sorted.map(info => info.name);
+    let seps = sorted.slice(0, sorted.length - 1 | 0).map(info => info.sep);
+    return {
+      TAG: "Composite",
+      _0: {
+        keys: keys,
+        seps: seps
+      }
+    };
+  }
+  let seen$2 = new Set();
+  let allTaggedFields = schemas.flatMap(extractTaggedFields).filter(f => {
+    if (seen$2.has(f)) {
+      return false;
+    } else {
+      seen$2.add(f);
+      return true;
+    }
+  });
+  let len = allTaggedFields.length;
+  if (len !== 1) {
+    if (len === 0) {
+      return Stdlib_JsError.throwWithMessage("DCB spec has no tagged fields — cannot derive partition tag");
+    }
+    let needsExplicitPartition = schemas.some(hasMultiTagVariant);
+    if (needsExplicitPartition) {
+      let context = Stdlib_Array.filterMap(namedSchemas, param => {
+        let variantNames = findMultiTagVariantNames(param[2]);
+        if (variantNames.length !== 0) {
+          return param[0] + ` (` + variantNames.join(", ") + `) @ ` + param[1];
+        }
+      }).join(", ");
+      let len$1 = allPartitionFields.length;
+      if (len$1 !== 1) {
+        if (len$1 !== 0) {
+          return Stdlib_JsError.throwWithMessage(`DCB spec has multiple fields annotated with @partitionTag (` + allPartitionFields.join(", ") + `) — only one is allowed — affected: ` + context);
+        } else {
+          return Stdlib_JsError.throwWithMessage(`DCB spec has variants with multiple tagged fields (` + allTaggedFields.join(", ") + `) but none is annotated with @partitionTag — affected: ` + context + ` — mark one field as the partition key`);
+        }
+      }
+      let singlePartition = allPartitionFields[0];
+      return {
+        TAG: "Simple",
+        _0: {
+          key: singlePartition
+        }
+      };
+    }
+    let sorted$1 = allTaggedFields.toSorted(Primitive_string.compare);
+    return {
+      TAG: "Simple",
+      _0: {
+        key: sorted$1[0]
+      }
+    };
+  }
+  let singleField = allTaggedFields[0];
+  return {
+    TAG: "Simple",
+    _0: {
+      key: singleField
+    }
+  };
+}
+
+function getPartitionTagValue(query, pt) {
+  return Stdlib_Array.filterMap(query, queryItem => {
+      let tags = queryItem.tags;
+      if (tags !== undefined) {
+        return Stdlib_Array.findMap(tags, tag => {
+          if (tag.key === pt.key) {
+            return tag.value;
+          }
+        });
+      }
+    })[0];
+}
+
+export {
+  tagSchema,
+  dcbTagId,
+  dcbPartitionTagId,
+  dcbCrossPartitionId,
+  dcbCompositePartitionMemberId,
+  dcbTagKeyOverrideId,
+  string,
+  stringForKey,
+  int,
+  partition,
+  crossPartition,
+  compositePartitionMember,
+  isCompositePartitionMember,
+  isTagged,
+  isTaggedArray,
+  isPartitionTag,
+  isCrossPartitionTag,
+  isCrossPartitionTaggedArray,
+  resolveTagKey,
+  resolveArrayTagKey,
+  jsonValueToString,
+  extractTagsFromProperties,
+  extractTagsFromJson,
+  extractTags,
+  extractVariantNames,
+  extractAllVariantNames,
+  isVariantPayloadBearing,
+  extractTagsFromPropertiesExpanded,
+  extractTagsFromJsonExpanded,
+  extractTagsExpanded,
+  hasTaggedArrayFields,
+  tagKeysOfProperties,
+  extractTagKeysByEventType,
+  mergeTagKeysByEventType,
+  narrowEventTypesForTags,
+  buildQueryFromCommand,
+  extractTaggedFields,
+  crossPartitionKeysOfProperties,
+  extractCrossPartitionTagKeys,
+  extractPartitionTagFields,
+  hasMultiTagVariant,
+  findMultiTagVariantNames,
+  extractCompositePartitionFieldsFromProperties,
+  extractCompositePartitionFields,
+  getCompositePartitionKeyValue,
+  derivePartitionTag,
+  getPartitionTagValue,
+}
+/* tagSchema Not a pure module */