@blitznocode/blitz-orm 0.0.42 → 0.0.44

package/dist/index.js

@@ -0,0 +1,1661 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_radash9 = require("radash");
+var import_typedb_client3 = require("typedb-client");
+
+// src/default.config.ts
+var defaultConfig = {
+  query: {
+    simplifiedLinks: true
+  },
+  mutation: {}
+};
+
+// src/helpers.ts
+var import_immer = __toESM(require("immer"));
+var import_object_traversal = require("object-traversal");
+var import_radash = require("radash");
+var getDbPath = (thing, attribute, shared) => shared ? attribute : `${thing}\xB7${attribute}`;
+var getPath = (dbPath) => {
+  const parts = dbPath.split("\xB7");
+  return parts[parts.length - 1];
+};
+var oFind = (obj, fn) => Object.values(Object.fromEntries(Object.entries(obj).filter(([k, v]) => fn(k, v))))[0];
+var oFilter = (obj, fn) => Object.fromEntries(Object.entries(obj).filter(([k, v]) => fn(k, v)));
+var enrichSchema = (schema) => {
+  const allLinkedFields = [];
+  const withExtensionsSchema = (0, import_immer.default)(
+    schema,
+    (draft) => (0, import_object_traversal.traverse)(
+      draft,
+      ({ key, value, meta }) => {
+        if (meta.depth !== 2) {
+          return;
+        }
+        if (key) {
+          value.dataFields = value.dataFields?.map((df) => ({
+            ...df,
+            dbPath: getDbPath(key, df.path, df.shared)
+          }));
+        }
+        if (value.extends) {
+          const extendedSchema = draft.entities[value.extends] || draft.relations[value.extends];
+          value;
+          value.idFields = extendedSchema.idFields ? (value.idFields || []).concat(extendedSchema.idFields) : value.idFields;
+          value.dataFields = extendedSchema.dataFields ? (value.dataFields || []).concat(
+            extendedSchema.dataFields.map((df) => {
+              let deepExtendedThing = value.extends;
+              let deepSchema = schema.entities[deepExtendedThing] || schema.relations[deepExtendedThing];
+              while (!deepSchema.dataFields?.find((deepDf) => deepDf.path === df.path)) {
+                deepExtendedThing = deepSchema.extends;
+                deepSchema = schema.entities[deepExtendedThing] || schema.relations[deepExtendedThing];
+              }
+              return {
+                ...df,
+                dbPath: getDbPath(deepExtendedThing, df.path, df.shared)
+              };
+            })
+          ) : value.dataFields;
+          value.linkFields = extendedSchema.linkFields ? (value.linkFields || []).concat(extendedSchema.linkFields) : value.linkFields;
+          if ("roles" in extendedSchema) {
+            const val = value;
+            const extendedRelationSchema = extendedSchema;
+            val.roles = val.roles || {};
+            val.roles = {
+              ...val.roles,
+              ...extendedRelationSchema.roles
+            };
+            if (Object.keys(val.roles).length === 0) {
+              val.roles = {};
+            }
+          }
+        }
+      },
+      { traversalType: "breadth-first" }
+    )
+  );
+  (0, import_object_traversal.traverse)(schema, ({ key, value, meta }) => {
+    if (key === "linkFields") {
+      const getThingTypes = () => {
+        if (!meta.nodePath) {
+          throw new Error("No path");
+        }
+        const [thingPath, thing] = meta.nodePath.split(".");
+        const thingType = thingPath === "entities" ? "entity" : thingPath === "relations" ? "relation" : "";
+        return {
+          thing,
+          thingType
+        };
+      };
+      const thingTypes = getThingTypes();
+      const withThing = !Array.isArray(value) ? [
+        {
+          ...value,
+          ...thingTypes
+        }
+      ] : value.map((x) => ({ ...x, ...thingTypes }));
+      allLinkedFields.push(...withThing);
+    }
+  });
+  const enrichedSchema = (0, import_immer.default)(
+    withExtensionsSchema,
+    (draft) => (0, import_object_traversal.traverse)(draft, ({ value, key, meta }) => {
+      if (meta.depth === 2 && value.idFields && !value.id) {
+        value.name = key;
+        const thingType = () => {
+          if (meta.nodePath?.split(".")[0] === "entities")
+            return "entity";
+          if (meta.nodePath?.split(".")[0] === "relations")
+            return "relation";
+          throw new Error("Unsupported node attributes");
+        };
+        value.thingType = thingType();
+        value.computedFields = [];
+        if ("roles" in value) {
+          const val = value;
+          Object.entries(val.roles).forEach(([roleKey, role]) => {
+            role.playedBy = allLinkedFields.filter((x) => x.relation === key && x.plays === roleKey) || [];
+          });
+        }
+        if ("linkFields" in value && value.linkFields) {
+          const val = value;
+          val.linkFields?.forEach((linkField) => {
+            if (linkField.target === "relation") {
+              linkField.oppositeLinkFieldsPlayedBy = [
+                {
+                  plays: linkField.path,
+                  thing: linkField.relation,
+                  thingType: "relation"
+                }
+              ];
+              return;
+            }
+            const allOppositeLinkFields = allLinkedFields.filter((x) => x.relation === linkField.relation && x.plays !== linkField.plays) || [];
+            linkField.oppositeLinkFieldsPlayedBy = allOppositeLinkFields;
+            const { filter } = linkField;
+            linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+              (x) => x.target === "role"
+            );
+            if (filter && Array.isArray(filter)) {
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                (lf) => filter.some((ft) => lf.thing === ft.$role)
+              );
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                (lf) => filter.some((ft) => lf.thing === ft.$thing)
+              );
+            }
+            if (filter && !Array.isArray(filter)) {
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                (lf) => lf.$role === filter.$role
+              );
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                (lf) => lf.thing === filter.$thing
+              );
+            }
+          });
+        }
+      }
+      if (typeof value === "object" && "playedBy" in value) {
+        if ([...new Set(value.playedBy?.map((x) => x.thing))].length > 1) {
+          throw new Error(
+            `Unsupported: roleFields can be only played by one thing. Role: ${key} path:${meta.nodePath}`
+          );
+        }
+        if (value.playedBy.length === 0) {
+          throw new Error(
+            `Unsupported: roleFields should be played at least by one thing. Role: ${key}, path:${meta.nodePath}`
+          );
+        }
+      }
+      if (meta.depth === 4 && (value.default || value.computedValue)) {
+        const [type, thingId] = meta.nodePath?.split(".") || [];
+        draft[type][thingId].computedFields.push(value.path);
+      }
+    })
+  );
+  return enrichedSchema;
+};
+var getCurrentSchema = (schema, node) => {
+  if (node.$entity) {
+    if (!(node.$entity in schema.entities)) {
+      throw new Error(`Missing entity '${node.$entity}' in the schema`);
+    }
+    return schema.entities[node.$entity];
+  }
+  if (node.$relation) {
+    if (!(node.$relation in schema.relations)) {
+      throw new Error(`Missing relation '${node.$relation}' in the schema`);
+    }
+    return schema.relations[node.$relation];
+  }
+  throw new Error(`Wrong schema or query for ${JSON.stringify(node)}`);
+};
+var getCurrentFields = (currentSchema, node) => {
+  const availableDataFields = currentSchema.dataFields?.map((x) => x.path);
+  const availableLinkFields = currentSchema.linkFields?.map((x) => x.path) || [];
+  const availableRoleFields = "roles" in currentSchema ? (0, import_radash.listify)(currentSchema.roles, (k) => k) : [];
+  const availableFields = [
+    ...availableDataFields || [],
+    ...availableLinkFields || [],
+    ...availableRoleFields || []
+  ];
+  const reservedRootFields = [
+    "$entity",
+    "$op",
+    "$id",
+    "$tempId",
+    "$filer",
+    "$relation",
+    "$parentKey",
+    "$filter",
+    "$fields"
+  ];
+  const allowedFields = [...reservedRootFields, ...availableFields];
+  if (!node) {
+    return {
+      fields: availableFields,
+      dataFields: availableDataFields,
+      roleFields: availableRoleFields,
+      linkFields: availableLinkFields
+    };
+  }
+  const usedFields = node.$fields ? node.$fields.map((x) => {
+    if (typeof x === "string")
+      return x;
+    if ("$path" in x)
+      return x.$path;
+    throw new Error(" Wrongly structured query");
+  }) : (0, import_radash.listify)(node, (k) => k);
+  const localFilterFields = !node.$filter ? [] : (0, import_radash.listify)(node.$filter, (k) => k.toString().startsWith("$") ? void 0 : k.toString()).filter(
+    (x) => x && availableDataFields?.includes(x)
+  );
+  const nestedFilterFields = !node.$filter ? [] : (0, import_radash.listify)(node.$filter, (k) => k.toString().startsWith("$") ? void 0 : k.toString()).filter(
+    (x) => x && [...availableRoleFields || [], ...availableLinkFields || []]?.includes(x)
+  );
+  const unidentifiedFields = [...usedFields, ...localFilterFields].filter((x) => !allowedFields.includes(x));
+  const localFilters = !node.$filter ? {} : oFilter(node.$filter, (k, _v) => localFilterFields.includes(k));
+  const nestedFilters = !node.$filter ? {} : oFilter(node.$filter, (k, _v) => nestedFilterFields.includes(k));
+  return {
+    fields: availableFields,
+    dataFields: availableDataFields,
+    roleFields: availableRoleFields,
+    linkFields: availableLinkFields,
+    unidentifiedFields,
+    ...localFilterFields.length ? { localFilters } : {},
+    ...nestedFilterFields.length ? { nestedFilters } : {}
+  };
+};
+var getLocalFilters = (currentSchema, node) => {
+  const localFilters = node.$localFilters && (0, import_radash.listify)(node.$localFilters, (k, v) => {
+    const currentDataField = currentSchema.dataFields?.find((x) => x.path === k);
+    return `has ${currentDataField?.dbPath} '${v}'`;
+  });
+  const localFiltersTql = localFilters?.length ? `, ${localFilters.join(",")}` : "";
+  return localFiltersTql;
+};
+
+// src/pipeline/control/dispatchPipeline.ts
+var import_radash6 = require("radash");
+
+// src/pipeline/postprocess/parseTQLRes.ts
+var import_radash2 = require("radash");
+var extractEntities = (conceptMapGroups, schema) => {
+  const bormEntities = conceptMapGroups.map((conceptMapGroup) => {
+    const conceptMaps = [...conceptMapGroup.conceptMaps];
+    const typeDBEntity = conceptMapGroup.owner.asThing();
+    const thingName = typeDBEntity.type.label.name;
+    const currentSchema = schema.entities[thingName] ? schema.entities[thingName] : schema.relations[thingName];
+    if (!currentSchema.idFields) {
+      throw new Error(`No idFields defined for ${thingName}`);
+    }
+    const thingType = schema.entities[thingName] ? "entity" : "relation";
+    const entityAttributes = conceptMaps.map((conceptMap) => {
+      const attribute = conceptMap.get("attribute")?.asAttribute();
+      if (!attribute) {
+        return [];
+      }
+      return [getPath(attribute.type.label.name), attribute.value];
+    });
+    const entity = Object.fromEntries(entityAttributes);
+    return {
+      ...entity,
+      [`$${thingType}`]: thingName,
+      $id: entity[currentSchema.idFields[0]]
+    };
+  });
+  return bormEntities;
+};
+var extractRelations = (conceptMapGroups, entityNames) => {
+  const relations = conceptMapGroups.flatMap((conceptMapGroup) => {
+    const relationsInGroup = conceptMapGroup.conceptMaps.map((conceptMap) => {
+      const link = /* @__PURE__ */ new Map();
+      entityNames.forEach((entityName) => {
+        const id = conceptMap.get(`${entityName}_id`)?.asAttribute().value.toString();
+        if (id)
+          link.set(entityName, id);
+      });
+      return link;
+    });
+    return relationsInGroup;
+  });
+  return relations;
+};
+var extractRoles = (conceptMapGroups, ownerPath, rolePath) => {
+  const roles = conceptMapGroups.flatMap((conceptMapGroup) => {
+    const rolesInGroup = conceptMapGroup.conceptMaps.map((conceptMap) => {
+      const ownerId = conceptMap.get(`${ownerPath}_id`)?.asAttribute().value.toString();
+      const roleId = conceptMap.get(`${rolePath}_id`)?.asAttribute().value.toString();
+      return {
+        ownerId,
+        path: rolePath,
+        roleId
+      };
+    });
+    return rolesInGroup;
+  });
+  return roles;
+};
+var parseTQLRes = async (req, res) => {
+  const { schema, bqlRequest, config, tqlRequest } = req;
+  const { rawTqlRes } = res;
+  if (!bqlRequest) {
+    throw new Error("BQL request not parsed");
+  } else if (!rawTqlRes) {
+    throw new Error("TQL query not executed");
+  }
+  const { query } = bqlRequest;
+  if (!query) {
+    if (rawTqlRes.insertions?.length === 0 && !tqlRequest?.deletions) {
+      throw new Error("Nothing has changed in DB, probably one of the ids specified in the mutation does not exist");
+    }
+    const { mutation } = bqlRequest;
+    if (!mutation) {
+      throw new Error("TQL mutation not executed");
+    }
+    const expected = [...mutation.things, ...mutation.edges];
+    const result = expected.map((x) => {
+      const currentNode = rawTqlRes.insertions?.[0].get(`${x.$tempId || x.$id}`);
+      if (x.$op === "create" || x.$op === "update" || x.$op === "link") {
+        if (!currentNode?.asThing().iid) {
+          throw new Error(`Thing not received on mutation: ${JSON.stringify(x)}`);
+        }
+        const dbIdd = currentNode?.asThing().iid;
+        if (config.mutation?.noMetadata) {
+          return (0, import_radash2.mapEntries)(x, (k, v) => [
+            k.toString().startsWith("$") ? Symbol.for(k) : k,
+            v
+          ]);
+        }
+        return { $dbId: dbIdd, ...x };
+      }
+      if (x.$op === "delete" || x.$op === "unlink") {
+        return x;
+      }
+      if (x.$op === "noop") {
+        return void 0;
+      }
+      throw new Error(`Unsupported op ${x.$op}`);
+    }).filter((x) => x);
+    res.bqlRes = result.length > 1 ? result : result[0];
+    return;
+  }
+  if (!rawTqlRes.entity) {
+    throw new Error("TQL query not executed");
+  }
+  const entities = extractEntities(rawTqlRes.entity, schema);
+  const relations = rawTqlRes.relations?.map((relation) => {
+    const currentRelSchema = schema.relations[relation.relation];
+    const currentRelroles = (0, import_radash2.listify)(
+      currentRelSchema.roles,
+      (_k, v) => {
+        if ([...new Set(v.playedBy?.map((x) => x.thing))].length !== 1) {
+          throw new Error("a role can be played by two entities throws the same relation");
+        }
+        if (!v.playedBy)
+          throw new Error("Role not being played by nobody");
+        return v.playedBy[0].thing;
+      }
+    );
+    const links = extractRelations(relation.conceptMapGroups, [
+      ...currentRelroles,
+      currentRelSchema.name
+    ]);
+    return {
+      name: relation.relation,
+      links
+    };
+  });
+  const roles = rawTqlRes.roles?.map((role) => {
+    return {
+      name: role.ownerPath,
+      links: extractRoles(role.conceptMapGroups, role.ownerPath, role.path)
+    };
+  });
+  const cache = res.cache || {
+    entities: /* @__PURE__ */ new Map(),
+    relations: /* @__PURE__ */ new Map(),
+    roleLinks: /* @__PURE__ */ new Map()
+  };
+  entities.forEach((entity) => {
+    const entityName = entity.$entity || entity.$relation;
+    const entityId = entity.$id;
+    const entityCache = cache.entities.get(entityName) || /* @__PURE__ */ new Map();
+    entityCache.set(entityId, { ...entity, $show: true });
+    cache.entities.set(entityName, entityCache);
+  });
+  relations?.forEach((relation) => {
+    const relationName = relation.name;
+    const relationCache = cache.relations.get(relationName) || [];
+    relationCache.push(...relation.links);
+    cache.relations.set(relationName, relationCache);
+    relation.links.forEach((link) => {
+      [...link.entries()].forEach(([entityName, entityId]) => {
+        const entityCache = cache.entities.get(entityName) || /* @__PURE__ */ new Map();
+        const getEntityThingType = () => {
+          if (schema.entities[entityName])
+            return "entity";
+          if (schema.relations[entityName])
+            return "relation";
+          throw new Error("Entity or relation not found");
+        };
+        const entityThingType = getEntityThingType();
+        const entity = {
+          [entityThingType]: entityName,
+          $id: entityId,
+          ...entityCache.get(entityId)
+        };
+        entityCache.set(entityId, entity);
+        cache.entities.set(entityName, entityCache);
+      });
+    });
+  });
+  roles?.forEach((role) => {
+    const ownerSchema = schema.relations[role.name] || schema.entities[role.name];
+    role.links.forEach((link) => {
+      const cachedLinks = cache.roleLinks.get(link.ownerId) || {};
+      let cachedLinkID = cachedLinks[link.path];
+      if (cachedLinkID) {
+        if ((0, import_radash2.isArray)(cachedLinkID)) {
+          cachedLinkID.push(link.roleId);
+        } else if ((0, import_radash2.isString)(cachedLinkID) && cachedLinkID !== link.roleId) {
+          cachedLinkID = [cachedLinkID, link.roleId];
+        }
+      } else {
+        cachedLinkID = link.roleId;
+      }
+      cachedLinks[link.path] = cachedLinkID;
+      cache.roleLinks.set(link.ownerId, cachedLinks);
+      ownerSchema.roles[link.path].playedBy?.forEach((roleSchema) => {
+        const entityCache = cache.entities.get(roleSchema.thing) || /* @__PURE__ */ new Map();
+        const entity = {
+          $entity: roleSchema.thing,
+          $id: link.roleId,
+          ...entityCache.get(link.roleId)
+        };
+        entityCache.set(link.roleId, entity);
+        cache.entities.set(roleSchema.thing, entityCache);
+      });
+    });
+  });
+  res.cache = cache;
+};
+
+// src/pipeline/postprocess/fieldsOperator.ts
+var import_radash3 = require("radash");
+
+// src/pipeline/postprocess/buildBQLTree.ts
+var import_immer2 = __toESM(require("immer"));
+var import_object_traversal2 = require("object-traversal");
+var import_radash4 = require("radash");
+var cleanOutput = (obj, config) => (0, import_immer2.default)(
+  obj,
+  (draft) => (0, import_object_traversal2.traverse)(
+    draft,
+    ({ value }) => {
+      if (Array.isArray(value) || !(typeof value === "object"))
+        return;
+      if (value.$fields) {
+        delete value.$fields;
+      }
+      if (value.$filter) {
+        delete value.$filter;
+      }
+      if (value.$show) {
+        delete value.$show;
+      }
+      if (config.query?.noMetadata && (value.$entity || value.$relation)) {
+        delete value.$entity;
+        delete value.$relation;
+        delete value.$id;
+      }
+      const symbols = Object.getOwnPropertySymbols(obj);
+      symbols.forEach((symbol) => {
+        delete value[symbol];
+      });
+    }
+  )
+);
+var filterChildrenEntities = (things, ids, node, path) => things.map(([id, entity]) => {
+  if (!ids)
+    return null;
+  if (!ids.includes(id))
+    return null;
+  if (!node.$fields)
+    return id;
+  if (node.$fields.includes(path))
+    return id;
+  const currentFieldConf = node.$fields.find((f) => (0, import_radash4.isObject)(f) && f.$path === path);
+  if (currentFieldConf) {
+    const onlyMetadataEntity = {
+      ...oFilter(entity, (k, _v) => k.startsWith("$"))
+    };
+    const withFieldsEntity = currentFieldConf.$fields ? {
+      ...onlyMetadataEntity,
+      $fields: currentFieldConf.$fields
+    } : onlyMetadataEntity;
+    if (currentFieldConf.$id) {
+      if (Array.isArray(currentFieldConf.$id)) {
+        if (currentFieldConf.$id.includes(id))
+          return withFieldsEntity;
+        return null;
+      }
+      if (currentFieldConf.$id === id)
+        return withFieldsEntity;
+    }
+    return withFieldsEntity;
+  }
+  return null;
+}).filter((x) => x);
+var buildBQLTree = async (req, res) => {
+  const { bqlRequest, config, schema } = req;
+  const { cache } = res;
+  if (!bqlRequest) {
+    throw new Error("BQL request not parsed");
+  }
+  const { query } = bqlRequest;
+  if (!query) {
+    res.bqlRes = cleanOutput(res.bqlRes, config);
+    return;
+  }
+  if (!cache) {
+    return;
+  }
+  const thingSchema = "$entity" in query ? query.$entity : query.$relation;
+  const entityMap = cache.entities.get(thingSchema.name);
+  if (!entityMap) {
+    res.bqlRes = null;
+    return;
+  }
+  const filterFields = (0, import_radash4.listify)(query.$filter, (x) => x);
+  const atLeastOneUnique = filterFields.some(
+    (x) => thingSchema.dataFields?.find((y) => y.path === x)?.validations?.unique
+  );
+  const monoOutput = !Array.isArray(bqlRequest.query) && (bqlRequest.query?.$id && !Array.isArray(bqlRequest.query?.$id) || atLeastOneUnique);
+  if (Array.isArray(req.rawBqlRequest)) {
+    throw new Error("Query arrays not implemented yet");
+  }
+  const rootThings = entityMap;
+  const structuredAnswer = [...rootThings].length ? [...rootThings].map(([id, _entity]) => ({
+    ...req.rawBqlRequest,
+    $id: id
+  })) : req.rawBqlRequest;
+  const bqlTree = (0, import_immer2.default)(
+    structuredAnswer,
+    (draft) => (0, import_object_traversal2.traverse)(draft, ({ value: val }) => {
+      const value = val;
+      if (!value?.$entity && !value?.$relation)
+        return;
+      const thingName = "$entity" in value ? value.$entity : value.$relation;
+      if (thingName) {
+        const currentIds = Array.isArray(value.$id) ? value.$id : [value.$id];
+        const currentSchema = "$relation" in value ? schema.relations[value.$relation] : schema.entities[value.$entity];
+        const { dataFields, roleFields } = getCurrentFields(currentSchema);
+        const currentEntities = cache.entities.get(thingName);
+        if (!currentEntities)
+          return;
+        [...currentEntities].forEach(([id, entity]) => {
+          if (currentIds.includes(id)) {
+            const queriedDataFields = value.$fields ? value.$fields : dataFields;
+            (0, import_radash4.listify)(entity, (k, v) => {
+              if (k.startsWith("$"))
+                return;
+              if (!queriedDataFields?.includes(k))
+                return;
+              value[k] = v;
+            });
+            const links = cache.roleLinks.get(id);
+            const flatRoleFields = value.$fields ? value.$fields.filter((x) => typeof x === "string") : roleFields;
+            const embeddedRoleFields = value.$fields?.filter((x) => typeof x === "object")?.map((y) => y.$path) || [];
+            Object.entries(links || {}).forEach(([rolePath, linkedIds]) => {
+              if (![...flatRoleFields, ...embeddedRoleFields].includes(rolePath)) {
+                return;
+              }
+              if (!("roles" in currentSchema))
+                throw new Error("No roles in schema");
+              const uniqueLinkedIds = !Array.isArray(linkedIds) ? [linkedIds] : [...new Set(linkedIds)];
+              const { cardinality, playedBy } = currentSchema.roles[rolePath];
+              const thingNames = [...new Set(playedBy?.map((x) => x.thing))];
+              const children = thingNames?.flatMap((x) => {
+                const thingEntities = cache.entities.get(x);
+                if (!thingEntities)
+                  return [];
+                return filterChildrenEntities([...thingEntities], uniqueLinkedIds, value, rolePath);
+              });
+              if (children?.length) {
+                if (children.length === 1 && children[0] === value.$id) {
+                  return;
+                }
+                if (cardinality === "ONE") {
+                  value[rolePath] = children[0];
+                  return;
+                }
+                value[rolePath] = children.filter(
+                  (x) => typeof x === "string" || typeof x === "object" && x?.$show
+                );
+              }
+            });
+          }
+        });
+        const currentLinkFields = currentSchema.linkFields;
+        if (currentLinkFields) {
+          currentLinkFields.forEach((linkField) => {
+            const currentRelation = cache.relations.get(linkField.relation);
+            const tunnel = linkField.oppositeLinkFieldsPlayedBy;
+            if (linkField.target === "relation") {
+              const targetRelation = tunnel[0];
+              const targetRelationThings = cache.relations.get(linkField.relation);
+              const matchedLinks = !targetRelationThings ? [] : [...targetRelationThings].filter((link) => {
+                return currentIds.includes(link.get(thingName));
+              }).map((x) => x.get(targetRelation.thing));
+              const targetRelationEntities = cache.entities.get(targetRelation.thing);
+              if (!targetRelationEntities)
+                return null;
+              const children = filterChildrenEntities(
+                [...targetRelationEntities],
+                matchedLinks,
+                value,
+                linkField.path
+              );
+              if (children.length) {
+                if (children.length === 1 && children[0] === value.$id) {
+                  return null;
+                }
+                if (linkField.cardinality === "ONE") {
+                  value[linkField.path] = children[0];
+                  return null;
+                }
+                value[linkField.path] = children.filter(
+                  (x) => typeof x === "string" || typeof x === "object" && x?.$show
+                );
+              }
+              return null;
+            }
+            if (linkField.target === "role") {
+              const linkFieldPlayers = tunnel.flatMap((t) => {
+                const allCurrentLinkFieldThings = cache.entities.get(t.thing);
+                const linkedIds = currentRelation ? [...currentRelation].filter((rel) => rel.get(thingName) === currentIds[0]).map((x) => x.get(t.thing)) : [];
+                const uniqueLinkedIds = [...new Set(linkedIds)];
+                if (!allCurrentLinkFieldThings)
+                  return null;
+                const children = filterChildrenEntities(
+                  [...allCurrentLinkFieldThings],
+                  uniqueLinkedIds,
+                  value,
+                  linkField.path
+                );
+                if (children.length) {
+                  return children.filter(
+                    (x) => typeof x === "string" || typeof x === "object" && x?.$show
+                  );
+                }
+                return null;
+              }).filter((x) => x);
+              if (linkFieldPlayers && linkFieldPlayers.length) {
+                if (linkField.cardinality === "ONE") {
+                  value[linkField.path] = linkFieldPlayers[0];
+                  return null;
+                }
+                value[linkField.path] = linkFieldPlayers;
+              }
+              return null;
+            }
+            return null;
+          });
+        }
+      }
+    })
+  );
+  const withoutFieldFilters = cleanOutput(bqlTree, config);
+  res.bqlRes = monoOutput ? withoutFieldFilters[0] : withoutFieldFilters;
+};
+
+// src/pipeline/preprocess/buildTQLQuery.ts
+var import_radash5 = require("radash");
+var buildTQLQuery = async (req) => {
+  const { schema, bqlRequest } = req;
+  if (!bqlRequest?.query) {
+    throw new Error("BQL query not parsed");
+  }
+  const { query } = bqlRequest;
+  const currentThingSchema = "$entity" in query ? query.$entity : query.$relation;
+  const thingPath = currentThingSchema.defaultDBConnector.path || currentThingSchema.name;
+  if (!currentThingSchema.idFields) {
+    throw new Error("No id fields");
+  }
+  const [idField] = currentThingSchema.idFields;
+  const idParam = `$${thingPath}_id`;
+  let idFilter = `, has ${idField} ${idParam};`;
+  if (query.$id) {
+    if (Array.isArray(query.$id)) {
+      idFilter += ` ${idParam} like "${query.$id.join("|")}";`;
+    } else {
+      idFilter += ` ${idParam} "${query.$id}";`;
+    }
+  }
+  const localFiltersTql = getLocalFilters(currentThingSchema, query);
+  const allRoles = "roles" in currentThingSchema ? (0, import_radash5.listify)(currentThingSchema.roles, (k, v) => ({
+    path: k,
+    var: `$${k}`,
+    schema: v
+  })) : [];
+  const queryStr = `match $${thingPath}  isa ${thingPath}, has attribute $attribute ${localFiltersTql} ${idFilter} group $${thingPath};`;
+  const rolesObj = allRoles.map((role) => {
+    if (!role.schema.playedBy || [...new Set(role.schema.playedBy?.map((x) => x.thing))].length !== 1) {
+      throw new Error("Unsupported: Role played by multiple linkfields or none");
+    }
+    const roleThingName = role.schema.playedBy[0].thing;
+    return {
+      path: role.path,
+      owner: thingPath,
+      request: `match $${thingPath} (${role.path}: ${role.var} ) isa ${thingPath} ${idFilter} ${role.var} isa ${roleThingName}, has id ${role.var}_id; group $${thingPath};`
+    };
+  });
+  const relations = currentThingSchema.linkFields?.flatMap((linkField) => {
+    const entityMatch = `match $${thingPath} isa ${thingPath}${localFiltersTql} ${idFilter}`;
+    const dirRel = linkField.target === "relation";
+    const tarRel = linkField.relation;
+    const relVar = `$${tarRel}`;
+    const relationMatchStart = `${dirRel ? relVar : ""} (${linkField.plays}: $${thingPath}`;
+    const relationMatchOpposite = linkField.oppositeLinkFieldsPlayedBy.map(
+      (link) => !dirRel ? `${link.plays}: $${link.thing}` : null
+    );
+    const roles = [relationMatchStart, ...relationMatchOpposite].filter((x) => x).join(",");
+    const relationPath = schema.relations[linkField.relation].defaultDBConnector.path || linkField.relation;
+    const relationMatchEnd = `) isa ${relationPath};`;
+    const relationIdFilters = linkField.oppositeLinkFieldsPlayedBy.map(
+      (link) => `$${link.thing} isa ${link.thing}, has id $${link.thing}_id;`
+    ).join(", ");
+    const group = `group $${thingPath};`;
+    const request = `${entityMatch} ${roles} ${relationMatchEnd} ${relationIdFilters} ${group}`;
+    return { relation: relationPath, entity: thingPath, request };
+  });
+  req.tqlRequest = {
+    entity: queryStr,
+    ...rolesObj?.length ? { roles: rolesObj } : {},
+    ...relations?.length ? { relations } : {}
+  };
+};
+
+// src/pipeline/preprocess/parseBQLQuery.ts
+var parseBQLQuery = async (req) => {
+  const { rawBqlRequest: rawBqlQuery, schema } = req;
+  if (!("$entity" in rawBqlQuery) && !("$relation" in rawBqlQuery)) {
+    throw new Error("No entity specified in query");
+  }
+  const currentSchema = getCurrentSchema(schema, rawBqlQuery);
+  if (!currentSchema) {
+    throw new Error(`Thing '${rawBqlQuery}' not found in schema`);
+  }
+  const { unidentifiedFields, localFilters, nestedFilters } = getCurrentFields(currentSchema, rawBqlQuery);
+  if (unidentifiedFields && unidentifiedFields.length > 0) {
+    throw new Error(`Unknown fields: [${unidentifiedFields.join(",")}] in ${JSON.stringify(rawBqlQuery)}`);
+  }
+  req.bqlRequest = {
+    query: {
+      ...req.rawBqlRequest,
+      ...currentSchema.thingType === "entity" ? { $entity: currentSchema } : {},
+      ...currentSchema.thingType === "relation" ? { $relation: currentSchema } : {},
+      ...localFilters ? { $localFilters: localFilters } : {},
+      ...nestedFilters ? { $nestedFilters: nestedFilters } : {}
+    }
+  };
+};
+
+// src/pipeline/transaction/runTQLQuery.ts
+var import_typedb_client = require("typedb-client");
+var runTQLQuery = async (req, res) => {
+  const { dbHandles, bqlRequest, tqlRequest, config } = req;
+  if (!bqlRequest) {
+    throw new Error("BQL request not parsed");
+  }
+  if (!tqlRequest) {
+    throw new Error("TQL request not built");
+  }
+  if (!tqlRequest.entity) {
+    throw new Error("BQL request error, no entities");
+  }
+  const { query } = bqlRequest;
+  if (!query) {
+    throw new Error("BQL request is not a query");
+  }
+  const singleHandlerV0 = config.dbConnectors[0].id;
+  const session = dbHandles.typeDB.get(singleHandlerV0)?.session;
+  if (!session?.isOpen()) {
+    throw new Error("Session is closed");
+  }
+  const transaction = await session.transaction(import_typedb_client.TransactionType.READ);
+  if (!transaction) {
+    throw new Error("Can't create transaction");
+  }
+  const entityStream = transaction.query.matchGroup(tqlRequest.entity);
+  const rolesStreams = tqlRequest.roles?.map((role) => ({
+    ...role,
+    stream: transaction.query.matchGroup(role.request)
+  }));
+  const relationStreams = tqlRequest.relations?.map((relation) => ({
+    ...relation,
+    stream: transaction.query.matchGroup(relation.request)
+  }));
+  const entityConceptMapGroups = await entityStream.collect();
+  const rolesConceptMapGroups = await Promise.all(
+    rolesStreams?.map(async (role) => ({
+      path: role.path,
+      ownerPath: role.owner,
+      conceptMapGroups: await role.stream.collect()
+    })) || []
+  );
+  const relationConceptMapGroups = await Promise.all(
+    relationStreams?.map(async (relation) => ({
+      relation: relation.relation,
+      entity: relation.entity,
+      conceptMapGroups: await relation.stream.collect()
+    })) || []
+  );
+  await transaction.close();
+  res.rawTqlRes = {
+    entity: entityConceptMapGroups,
+    ...rolesConceptMapGroups?.length && { roles: rolesConceptMapGroups },
+    ...relationConceptMapGroups?.length && {
+      relations: relationConceptMapGroups
+    }
+  };
+};
+
+// src/pipeline/control/dispatchPipeline.ts
+var dispatchPipeline = async (req, res) => {
+  const { bqlRequest, schema } = req;
+  const { cache } = res;
+  if (!bqlRequest) {
+    throw new Error("BQL request not parsed");
+  }
+  if (!cache) {
+    throw new Error("Cache not initialized");
+  }
+  const { query } = bqlRequest;
+  if (!query) {
+    return;
+  }
+  const { $fields } = query;
+  if (!("$entity" in query) && !("$relation" in query)) {
+    throw new Error("Node attributes not supported");
+  }
+  const $thing = "$entity" in query ? query.$entity : query.$relation;
+  if (!$fields || !Array.isArray($fields)) {
+    return;
+  }
+  const expandedLinkAndRoleFields = $fields.filter((f) => typeof f !== "string" && f.$path);
+  const nestedThingsByLF = $thing.linkFields?.filter(
+    (linkField) => expandedLinkAndRoleFields.findIndex(
+      (expanded) => expanded.$path === linkField.path
+    ) !== -1
+  ).flatMap((linkField) => linkField.oppositeLinkFieldsPlayedBy) || [];
+  const nestedThingsByRF = "roles" in $thing ? (0, import_radash6.listify)($thing.roles, (k, v) => {
+    if (expandedLinkAndRoleFields.findIndex(
+      (expanded) => expanded.$path === k
+    ) !== -1) {
+      return v;
+    }
+    return null;
+  }).flatMap((role) => role?.playedBy).filter((x) => x) : [];
+  const nestedThings = [...nestedThingsByLF, ...nestedThingsByRF];
+  const nextOps = nestedThings?.map((linkField) => {
+    if (!linkField)
+      return null;
+    const { thing } = linkField;
+    const result = cache.entities.get(thing);
+    const resultIds = [...result?.keys() || []];
+    const currentSchema = schema.entities[thing] ? { ...schema.entities[thing], thingType: "entity" } : { ...schema.relations[thing], thingType: "relation" };
+    const $FieldsObj = $fields.find(
+      (x) => typeof x === "object" && x.$path === linkField.plays
+    );
+    const localIdsTemp = $FieldsObj?.$id;
+    const localIds = !localIdsTemp ? [] : Array.isArray(localIdsTemp) ? localIdsTemp : [localIdsTemp];
+    const localFilters = $FieldsObj?.$filter;
+    const commonIds = !localIds.length ? resultIds : localIds.filter((id) => resultIds.includes(id));
+    const newBqlRequest = {
+      query: {
+        $id: commonIds,
+        $fields: $FieldsObj?.$fields,
+        ...currentSchema.thingType === "entity" ? { $entity: currentSchema } : {},
+        ...currentSchema.thingType === "relation" ? { $relation: currentSchema } : {},
+        ...localFilters ? { $localFilters: localFilters } : {}
+      }
+    };
+    return {
+      req: {
+        ...req,
+        bqlRequest: newBqlRequest
+      },
+      res,
+      pipeline: [buildTQLQuery, runTQLQuery, parseTQLRes, dispatchPipeline]
+    };
+  }).filter((x) => x);
+  if (nextOps?.length) {
+    return nextOps;
+  }
+};
+
+// src/pipeline/preprocess/buildTQLMutation.ts
+var import_radash7 = require("radash");
+var buildTQLMutation = async (req) => {
+  const { bqlRequest, schema } = req;
+  if (!bqlRequest) {
+    throw new Error("BQL request not parsed");
+  }
+  const { mutation } = bqlRequest;
+  if (!mutation) {
+    throw new Error("BQL request is not a mutation");
+  }
+  const nodeToTypeQL = (node) => {
+    const op = node.$op;
+    const id = node.$tempId || node.$id;
+    const currentSchema = getCurrentSchema(schema, node);
+    const thingDbPath = currentSchema.defaultDBConnector?.path || node.$entity || node.$relation;
+    const { idFields } = currentSchema;
+    if (!idFields)
+      throw new Error("no idFields");
+    const idField = idFields[0];
+    const attributes = (0, import_radash7.listify)(node, (k, v) => {
+      if (k.startsWith("$") || k === idField || !v)
+        return "";
+      const currentDataField = currentSchema.dataFields?.find((x) => x.path === k);
+      const fieldDbPath = currentDataField?.path;
+      if (!fieldDbPath) {
+        return ``;
+      }
+      const dbField = currentDataField.dbPath;
+      if (["TEXT", "ID", "EMAIL"].includes(currentDataField.contentType)) {
+        return `has ${dbField} '${v}'`;
+      }
+      if (["NUMBER"].includes(currentDataField.contentType)) {
+        return `has ${dbField} ${v}`;
+      }
+      if (currentDataField.contentType === "DATE") {
+        if (Number.isNaN(v.valueOf())) {
+          throw new Error("Invalid format, Nan Date");
+        }
+        if (v instanceof Date) {
+          return `has ${dbField} ${v.toISOString().replace("Z", "")}`;
+        }
+        return `has ${dbField} ${new Date(v).toISOString().replace("Z", "")}`;
+      }
+      throw new Error(`Unsupported contentType ${currentDataField.contentType}`);
+    }).filter((x) => x);
+    const attributesVar = `$${id}-atts`;
+    const matchAttributes = (0, import_radash7.listify)(node, (k, v) => {
+      if (k.startsWith("$") || k === idField || !v)
+        return "";
+      const currentDataField = currentSchema.dataFields?.find((x) => x.path === k);
+      const fieldDbPath = currentDataField?.path;
+      if (!fieldDbPath) {
+        return ``;
+      }
+      const dbField = currentDataField.dbPath;
+      return `{${attributesVar} isa ${dbField};}`;
+    }).filter((x) => x);
+    const idFieldValue = node[idField] || node.$id;
+    const idDataField = currentSchema.dataFields?.find((x) => x.path === idField);
+    const idDefaultValue = node.$op === "create" ? idDataField?.default?.value() : null;
+    const idValue = idFieldValue || idDefaultValue;
+    const idAttributes = idValue ? [`has ${idField} '${idValue}'`] : [];
+    const allAttributes = [...idAttributes, ...attributes].filter((x) => x).join(",");
+    const getDeletionMatch = () => {
+      if (node.$tempId)
+        return "";
+      if (op === "delete" || op === "unlink" || op === "noop") {
+        return `$${id} isa ${[thingDbPath, ...idAttributes].filter((x) => x).join(",")};`;
+      }
+      if (op === "update") {
+        if (!matchAttributes.length)
+          throw new Error("update without attributes");
+        return `$${id} isa ${thingDbPath}, ${idAttributes[0]}, has ${attributesVar};
+        ${matchAttributes.join(" or ")};
+      `;
+      }
+      return "";
+    };
+    const getInsertionMatch = () => {
+      if (node.$tempId)
+        return "";
+      if (op === "update" || op === "link" || op === "noop") {
+        return `$${id} isa ${[thingDbPath, ...idAttributes].filter((x) => x).join(",")};`;
+      }
+      return "";
+    };
+    if (node.$entity || node.$relation) {
+      return {
+        op,
+        deletionMatch: getDeletionMatch(),
+        insertionMatch: getInsertionMatch(),
+        insertion: op === "create" ? `$${id} isa ${[thingDbPath, allAttributes].filter((x) => x).join(",")};` : op === "update" && attributes.length ? `$${id} ${attributes.join(",")};` : "",
+        deletion: op === "delete" ? `$${id} isa ${thingDbPath};` : op === "update" && matchAttributes.length ? `$${id} has ${attributesVar};` : ""
+      };
+    }
+    throw new Error("in attributes");
+  };
+  const edgeToTypeQL = (node) => {
+    const op = node.$op;
+    const id = node.$tempId || node.$id;
+    const currentSchema = getCurrentSchema(schema, node);
+    const relationDbPath = currentSchema.defaultDBConnector?.path || node.$relation;
+    const roleFields = "roles" in currentSchema ? (0, import_radash7.listify)(currentSchema.roles, (k) => k) : [];
+    const roleDbPaths = node.$relation && "roles" in currentSchema && (0, import_radash7.mapEntries)(currentSchema.roles, (k, v) => [k, v.dbConnector?.path || k]);
+    const fromRoleFields = (0, import_radash7.listify)(node, (k, v) => {
+      if (!roleFields.includes(k))
+        return null;
+      if (!("roles" in currentSchema)) {
+        throw new Error("This should have roles! ");
+      }
+      const roleDbPath = roleDbPaths[k];
+      if (Array.isArray(v)) {
+        return v.map((x) => ({ path: roleDbPath, id: x }));
+      }
+      return { path: roleDbPath, id: v };
+    }).filter((x) => x).flat();
+    const fromRoleFieldsTql = fromRoleFields.map((x) => x ? `${x.path}: $${x.id}` : "");
+    const roles = fromRoleFields.length > 0 ? `( ${fromRoleFieldsTql.join(" , ")} )` : "";
+    const relationTql = !roles ? "" : `$${id} ${roles} ${node[Symbol.for("edgeType")] === "linkField" ? `isa ${relationDbPath}` : ""}`;
+    const getInsertions = () => {
+      if (!relationTql)
+        return "";
+      if (op === "link")
+        return `${relationTql};`;
+      if (op === "create")
+        return `${relationTql}, has id '${id}';`;
+      return "";
+    };
+    const getDeletions = () => {
+      if (!relationTql)
+        return "";
+      if (op === "unlink")
+        return `${relationTql};`;
+      return "";
+    };
+    return {
+      deletionMatch: "",
+      insertionMatch: "",
+      deletion: getDeletions(),
+      insertion: getInsertions(),
+      op: ""
+    };
+  };
+  const toTypeQL = (nodes, mode) => {
+    const typeQL = mode === "edges" ? edgeToTypeQL : nodeToTypeQL;
+    if (Array.isArray(nodes)) {
+      return nodes.map((x) => {
+        const { insertionMatch: insertionMatch2, deletionMatch: deletionMatch2, insertion: insertion2, deletion: deletion2 } = typeQL(x);
+        return (0, import_radash7.shake)({ insertionMatch: insertionMatch2, deletionMatch: deletionMatch2, insertion: insertion2, deletion: deletion2 }, (z) => !z);
+      }).filter((y) => y);
+    }
+    const { insertionMatch, deletionMatch, insertion, deletion } = typeQL(nodes);
+    return (0, import_radash7.shake)({ insertionMatch, deletionMatch, insertion, deletion }, (z) => !z);
+  };
+  const nodeOperations = toTypeQL(mutation.things);
+  const arrayNodeOperations = Array.isArray(nodeOperations) ? nodeOperations : [nodeOperations];
+  const edgeOperations = toTypeQL(mutation.edges, "edges");
+  const arrayEdgeOperations = Array.isArray(edgeOperations) ? edgeOperations : [edgeOperations];
+  const allOperations = [...arrayNodeOperations, ...arrayEdgeOperations];
+  const tqlRequest = (0, import_radash7.shake)(
+    {
+      insertionMatches: allOperations.map((x) => x.insertionMatch).join(" ").trim(),
+      deletionMatches: allOperations.map((x) => x.deletionMatch).join(" ").trim(),
+      insertions: allOperations.map((x) => x.insertion).join(" ").trim(),
+      deletions: allOperations.map((x) => x.deletion).join(" ").trim()
+    },
+    (x) => !x
+  );
+  req.tqlRequest = tqlRequest;
+};
+
+// src/pipeline/preprocess/parseBQLMutation.ts
+var import_immer3 = __toESM(require("immer"));
+var import_object_traversal3 = require("object-traversal");
+var import_radash8 = require("radash");
+var import_uuid = require("uuid");
+var parseBQLMutation = async (req) => {
+  const { rawBqlRequest, schema } = req;
+  const stringToObjects = (blocks) => {
+    return (0, import_immer3.default)(
+      blocks,
+      (draft) => (0, import_object_traversal3.traverse)(draft, ({ value: val, meta }) => {
+        if ((0, import_radash8.isObject)(val)) {
+          if (val.$arrayOp) {
+            throw new Error("Array op not supported yet");
+          }
+          const value = val;
+          const currentSchema = getCurrentSchema(schema, val);
+          if (!currentSchema) {
+            throw new Error(
+              `Schema not found for ${val.$entity || val.$relation}`
+            );
+          }
+          value[Symbol.for("thingType")] = currentSchema.thingType;
+          value[Symbol.for("schema")] = currentSchema;
+          value[Symbol.for("dbId")] = currentSchema.defaultDBConnector.id;
+          const { linkFields, roleFields } = getCurrentFields(currentSchema);
+          const currentPath = meta.nodePath;
+          [
+            ...linkFields.map((x) => ({ fieldType: "linkField", path: x })),
+            ...roleFields.map((x) => ({ fieldType: "roleField", path: x }))
+          ]?.forEach((currentField) => {
+            const currentLinkFieldSchema = currentSchema.linkFields?.find((x) => x.path === currentField.path);
+            const currentValue = value[currentField.path];
+            if (currentValue === void 0)
+              return;
+            const currentRoleFieldSchema = "roles" in currentSchema ? oFind(currentSchema.roles, (k) => k === currentField.path) : null;
+            const currentFieldSchema = currentLinkFieldSchema || currentRoleFieldSchema;
+            if (currentRoleFieldSchema && [...new Set(currentRoleFieldSchema.playedBy?.map((x) => x.thing))].length !== 1) {
+              throw new Error(
+                `Field: ${currentField.path} - If a role can be played by multiple things, you must specify the thing in the mutation: ${JSON.stringify(
+                  currentRoleFieldSchema.playedBy
+                )}. Schema: ${JSON.stringify(currentFieldSchema)}`
+              );
+            }
+            const currentEdgeSchema = currentRoleFieldSchema?.playedBy ? currentRoleFieldSchema?.playedBy[0] : currentLinkFieldSchema;
+            const getCurrentRelation = () => {
+              if (currentFieldSchema && "relation" in currentFieldSchema && currentEdgeSchema?.relation === value.$relation) {
+                return "$self";
+              }
+              if (currentEdgeSchema?.relation) {
+                return currentEdgeSchema?.relation;
+              }
+              return "$self";
+            };
+            const relation = getCurrentRelation();
+            const relationSchema = relation === "$self" ? currentSchema : schema.relations[relation];
+            const currentFieldRole = oFind(relationSchema.roles, (k, _v) => k === currentField.path);
+            if (currentFieldRole?.playedBy?.length === 0)
+              throw new Error(`unused role: ${currentPath}.${currentField.path}`);
+            if (!currentFieldSchema) {
+              throw new Error(`Field ${currentField.path} not found in schema`);
+            }
+            const oppositeFields = currentLinkFieldSchema?.oppositeLinkFieldsPlayedBy || currentRoleFieldSchema?.playedBy;
+            if (!oppositeFields) {
+              throw new Error(`No opposite fields found for ${JSON.stringify(currentFieldSchema)}`);
+            }
+            if ([...new Set(oppositeFields?.map((x) => x.thing))].length > 1)
+              throw new Error(
+                `Field: ${currentField.path} - If a role can be played by multiple things, you must specify the thing in the mutation: ${JSON.stringify(
+                  oppositeFields
+                )}. Schema: ${JSON.stringify(currentFieldSchema)}`
+              );
+            if (currentValue === null) {
+              value[currentField.path] = { $op: "unlink" };
+            }
+            if (currentFieldSchema.cardinality === "ONE" && Array.isArray(currentValue)) {
+              throw new Error(`Can't have an array in a cardinality === ONE link field`);
+            }
+            if (currentValue.$entity || currentValue.$relation)
+              return;
+            const childrenLinkField = oppositeFields[0];
+            const childrenThingObj = {
+              [`$${childrenLinkField.thingType}`]: childrenLinkField.thing,
+              [Symbol.for("relation")]: relation,
+              [Symbol.for("edgeType")]: "plays" in currentFieldSchema ? "linkField" : "roleField",
+              [Symbol.for("parent")]: {
+                path: currentPath,
+                id: value.$id || value.$tempId,
+                links: oppositeFields
+              },
+              [Symbol.for("role")]: childrenLinkField.plays,
+              [Symbol.for("oppositeRole")]: "plays" in currentFieldSchema ? currentFieldSchema.plays : void 0
+            };
+            if ((0, import_radash8.isObject)(currentValue)) {
+              if (currentSchema.thingType === "relation" && currentValue.$tempId) {
+                value[currentField.path] = currentValue.$tempId;
+              } else {
+                value[currentField.path] = {
+                  ...childrenThingObj,
+                  ...currentValue
+                };
+              }
+            }
+            if (Array.isArray(currentValue) && currentValue.every((x) => (0, import_radash8.isObject)(x))) {
+              value[currentField.path] = currentValue.map((y) => ({
+                ...childrenThingObj,
+                ...y
+              }));
+            }
+            if (typeof currentValue === "string") {
+              value[currentField.path] = {
+                ...childrenThingObj,
+                $op: "link",
+                $id: currentValue
+              };
+            }
+            if (Array.isArray(currentValue) && currentValue.every((x) => typeof x === "string")) {
+              value[currentField.path] = currentValue.map((y) => ({
+                ...childrenThingObj,
+                $op: "link",
+                $id: y
+              }));
+            }
+          });
+          const nodePathArray = meta.nodePath?.split(".");
+          const notRoot = nodePathArray?.filter((x) => Number.isNaN(parseInt(x, 10))).join(".");
+          if (!notRoot && !value.$entity && !value.$relation) {
+            throw new Error("Root things must specify $entity or $relation");
+          }
+          if (!notRoot) {
+          }
+        }
+      })
+    );
+  };
+  const withObjects = stringToObjects(rawBqlRequest);
+  const fillBlocks = (blocks) => {
+    return (0, import_immer3.default)(
+      blocks,
+      (draft) => (0, import_object_traversal3.traverse)(draft, ({ parent, key, value: val, meta }) => {
+        if ((0, import_radash8.isObject)(val)) {
+          if (Object.keys(val).length === 0) {
+            throw new Error("Empty object!");
+          }
+          const value = val;
+          const nodePathArray = meta.nodePath?.split(".");
+          const notRoot = nodePathArray?.filter((x) => Number.isNaN(parseInt(x, 10))).join(".");
+          const currentSchema = getCurrentSchema(schema, value);
+          const { unidentifiedFields, dataFields, roleFields, linkFields } = getCurrentFields(currentSchema, value);
+          const hasUpdatedDataFields = Object.keys(value).some((x) => dataFields?.includes(x));
+          const hasUpdatedChildren = Object.keys(value).some((x) => [...roleFields, ...linkFields]?.includes(x));
+          const getOp = () => {
+            if (value.$op)
+              return value.$op;
+            if ((value.$id || value.$filter) && hasUpdatedDataFields)
+              return "update";
+            if ((value.$id || value.$filter) && notRoot && !hasUpdatedDataFields && !hasUpdatedChildren)
+              return "link";
+            if (!value.$filter && !value.$id)
+              return "create";
+            if ((value.$id || value.$filter) && !hasUpdatedDataFields && hasUpdatedChildren)
+              return "noop";
+            throw new Error("Wrong op");
+          };
+          if (!value.$op)
+            value.$op = getOp();
+          if (!parent)
+            value.$parentKey = "";
+          if (!(value.$id || value.$tempId || value.$filter) && ["delete", "link", "update", "unlink"].includes(value.$op)) {
+            throw new Error("Targeted operations (update, delete, link & unlink) require an $id or a $filter");
+          }
+          if (typeof parent === "object") {
+            const ArParent = Array.isArray(parent);
+            if (ArParent)
+              value[Symbol.for("index")] = key;
+            value[Symbol.for("path")] = meta.nodePath;
+            value[Symbol.for("isRoot")] = !notRoot;
+            value[Symbol.for("depth")] = notRoot?.split(".").length;
+          }
+          if (!value.$entity && !value.$relation) {
+            throw new Error(`Node ${JSON.stringify(value)} without $entity/$relation`);
+          }
+          const { idFields, computedFields } = currentSchema;
+          if (!idFields)
+            throw new Error("No idFields found");
+          const idField = idFields[0];
+          if (value[idField] && !value.$id) {
+            value.$id = value[idField];
+          }
+          const filledFields = (0, import_radash8.listify)(value, (attKey, v) => v ? attKey : void 0);
+          const missingComputedFields = computedFields.filter((x) => !filledFields.includes(x));
+          missingComputedFields.forEach((fieldPath) => {
+            const currentFieldDef = currentSchema.dataFields?.find((x) => x.path === fieldPath);
+            const currentLinkDef = currentSchema.linkFields?.find((x) => x.path === fieldPath);
+            const currentLinkedDef = currentLinkDef?.oppositeLinkFieldsPlayedBy[0];
+            const currentRoleDef = "roles" in currentSchema ? oFind(currentSchema.roles, (k, _v) => k === fieldPath) : void 0;
+            const currentDef = currentFieldDef || currentLinkedDef || currentRoleDef;
+            if (!currentDef) {
+              throw new Error(`no field Def for ${fieldPath}`);
+            }
+            if (fieldPath === idField && value.$op === "create" && !value[fieldPath]) {
+              const defaultValue = "default" in currentDef ? currentDef.default?.value() : void 0;
+              if (!defaultValue) {
+                throw new Error(`No default value for ${fieldPath}`);
+              }
+              value[fieldPath] = defaultValue;
+              value.$id = defaultValue;
+            }
+          });
+          if (unidentifiedFields.length > 0) {
+            throw new Error(`Unknown fields: [${unidentifiedFields.join(",")}] in ${JSON.stringify(value)}`);
+          }
+        }
+      })
+    );
+  };
+  const filledBQLMutation = fillBlocks(withObjects);
+  const listNodes = (blocks) => {
+    const nodes = [];
+    const edges = [];
+    const listOp = ({ value }) => {
+      if (value.$entity || value.$relation) {
+        if (!value.$id && !["link", "unlink"].includes(value.$op)) {
+          throw new Error(
+            "An id must be specified either in the mutation or has tu have a default value in the schema"
+          );
+        }
+        const currentThingSchema = getCurrentSchema(schema, value);
+        const { dataFields: dataFieldPaths, roleFields: roleFieldPaths } = getCurrentFields(currentThingSchema);
+        const dataObj = {
+          ...value.$entity && { $entity: value.$entity },
+          ...value.$relation && { $relation: value.$relation },
+          ...value.$id && { $id: value.$id },
+          ...value.$tempId && { $tempId: value.$tempId },
+          ...(0, import_radash8.shake)((0, import_radash8.pick)(value, dataFieldPaths || [""])),
+          $op: value.$op,
+          [Symbol.for("dbId")]: currentThingSchema.defaultDBConnector.id,
+          [Symbol.for("isRoot")]: value[Symbol.for("isRoot")]
+        };
+        if (value.$op === "create" || value.$op === "update" || value.$op === "delete") {
+          nodes.push(dataObj);
+        } else {
+          nodes.push({ ...dataObj, $op: "noop" });
+        }
+        if (value[Symbol.for("relation")] && value[Symbol.for("edgeType")] === "linkField") {
+          if (value.$op === "link" || value.$op === "unlink") {
+            if (value.$id || value.$filter) {
+              if (value.$tempId) {
+                throw new Error("can't specify a existing and a new element at once. Use an id/filter or a tempId");
+              }
+              nodes.push({ ...value, $op: "noop" });
+            }
+          }
+          const ownRelation = value[Symbol.for("relation")] === value.$relation;
+          if (ownRelation && !(value.$id || value.$tempId)) {
+            throw new Error("No id or tempId found for complex link");
+          }
+          const linkTempId = ownRelation ? value.$id || value.$tempId : (0, import_uuid.v4)();
+          const parentMeta = value[Symbol.for("parent")];
+          const parentPath = parentMeta.path;
+          const parentNode = !parentPath ? blocks : (0, import_object_traversal3.getNodeByPath)(blocks, parentPath);
+          const parentId = parentNode.$id || parentNode.$tempId;
+          if (!parentId)
+            throw new Error("No parent id found");
+          if (value[Symbol.for("relation")] === "$self")
+            return;
+          const getLinkObjOp = () => {
+            if (value.$op === "unlink" || value.$op === "delete") {
+              if (ownRelation)
+                return "unlink";
+              return "delete";
+            }
+            if (value.$op === "link" || value.$op === "create") {
+              if (ownRelation)
+                return "link";
+              return "create";
+            }
+            return "noop";
+          };
+          const linkObj = {
+            $relation: value[Symbol.for("relation")],
+            $op: getLinkObjOp(),
+            ...value.$op === "unlink" ? { $tempId: linkTempId } : { $id: linkTempId },
+            [value[Symbol.for("role")]]: value.$tempId || value.$id,
+            [value[Symbol.for("oppositeRole")]]: parentId,
+            [Symbol.for("isRoot")]: false,
+            [Symbol.for("dbId")]: schema.relations[value[Symbol.for("relation")]].defaultDBConnector.id,
+            [Symbol.for("edgeType")]: "linkField"
+          };
+          edges.push(linkObj);
+        }
+        if (value.$relation) {
+          const val = value;
+          if (!val.$id && !["link", "unlink"].includes(value.$op)) {
+            throw new Error(
+              "An id must be specified either in the mutation or has tu have a default value in the schema"
+            );
+          }
+          const rolesObjFiltered = oFilter(val, (k, _v) => roleFieldPaths.includes(k));
+          const rolesObjOnlyIds = (0, import_radash8.mapEntries)(rolesObjFiltered, (k, v) => {
+            return [k, v.$id || v];
+          });
+          const objWithMetaDataOnly = oFilter(val, (k, _v) => {
+            return k.startsWith("$") || k.startsWith("Symbol");
+          });
+          if (Object.keys(rolesObjFiltered).filter((x) => !x.startsWith("$")).length > 0) {
+            if (val.$op === "create" || val.$op === "delete") {
+              const getEdgeOp = () => {
+                if (val.$op === "create")
+                  return "link";
+                if (val.$op === "delete")
+                  return "unlink";
+                throw new Error("Unsupported parent of edge op");
+              };
+              edges.push({
+                ...objWithMetaDataOnly,
+                $relation: val.$relation,
+                $op: getEdgeOp(),
+                ...rolesObjOnlyIds,
+                [Symbol.for("dbId")]: currentThingSchema.defaultDBConnector.id,
+                [Symbol.for("info")]: "coming from created or deleted relation"
+              });
+              return;
+            }
+            if (val.$op === "noop") {
+              const rolesWithLinks = oFilter(
+                rolesObjOnlyIds,
+                (_k, v) => v.some(
+                  (x) => x.$op === "link" || x.$op === "create"
+                )
+              );
+              const rolesWithLinksFiltered = (0, import_radash8.mapEntries)(rolesWithLinks, (k, v) => [
+                k,
+                v.filter((x) => x.$op === "link" || x.$op === "create").map((y) => y.$id)
+              ]);
+              const rolesWithUnlinks = oFilter(
+                rolesObjOnlyIds,
+                (_k, v) => v.some((x) => x.$op === "unlink" || x.$op === "delete")
+              );
+              const rolesWithUnlinksFiltered = (0, import_radash8.mapEntries)(rolesWithUnlinks, (k, v) => [
+                k,
+                v.filter((x) => x.$op === "unlink" || x.$op === "delete").map((y) => y.$id)
+              ]);
+              const rolesWithReplaces = {};
+              [
+                { op: "link", obj: rolesWithLinksFiltered },
+                { op: "unlink", obj: rolesWithUnlinksFiltered },
+                { op: "replace", obj: rolesWithReplaces }
+              ].forEach((x) => {
+                if (Object.keys(x.obj).length) {
+                  edges.push({
+                    ...objWithMetaDataOnly,
+                    $relation: val.$relation,
+                    $op: x.op,
+                    ...x.obj,
+                    [Symbol.for("dbId")]: currentThingSchema.defaultDBConnector.id,
+                    [Symbol.for("info")]: "updating roleFields"
+                  });
+                }
+              });
+            }
+          }
+        }
+      }
+    };
+    (0, import_object_traversal3.traverse)(blocks, listOp);
+    return [nodes, edges];
+  };
+  const [parsedThings, parsedEdges] = listNodes(filledBQLMutation);
+  const mergedEdges = parsedEdges.reduce((acc, curr) => {
+    const existingEdge = acc.find((r) => r.$id === curr.$id && r.$relation === curr.$relation);
+    if (existingEdge) {
+      const newRelation = {
+        ...existingEdge,
+        ...curr
+      };
+      const newAcc = acc.filter((r) => r.$id !== curr.$id || r.$relation !== curr.$relation);
+      return [...newAcc, newRelation];
+    }
+    return [...acc, curr];
+  }, []);
+  req.bqlRequest = {
+    mutation: {
+      things: parsedThings,
+      edges: mergedEdges
+    }
+  };
+};
+
+// src/pipeline/transaction/runTQLMutation.ts
+var import_typedb_client2 = require("typedb-client");
+var runTQLMutation = async (req, res) => {
+  const { dbHandles, tqlRequest, bqlRequest, config } = req;
+  if (!tqlRequest) {
+    throw new Error("TQL request not built");
+  }
+  if (!(tqlRequest.deletions && tqlRequest.deletionMatches || tqlRequest.insertions)) {
+    throw new Error("TQL request error, no things");
+  }
+  if (!bqlRequest?.mutation) {
+    throw new Error("BQL mutation not parsed");
+  }
+  const singleHandlerV0 = config.dbConnectors[0].id;
+  const session = dbHandles.typeDB.get(singleHandlerV0)?.session;
+  if (!session?.isOpen()) {
+    throw new Error("Session is closed");
+  }
+  const mutateTransaction = await session.transaction(import_typedb_client2.TransactionType.WRITE);
+  if (!mutateTransaction) {
+    throw new Error("Can't create transaction");
+  }
+  const tqlDeletion = tqlRequest.deletionMatches && tqlRequest.deletions && `match ${tqlRequest.deletionMatches} delete ${tqlRequest.deletions}`;
+  const tqlInsertion = tqlRequest.insertions && `${tqlRequest.insertionMatches ? `match ${tqlRequest.insertionMatches}` : ""} insert ${tqlRequest.insertions}`;
+  if (tqlDeletion)
+    mutateTransaction.query.delete(tqlDeletion);
+  const insertionsStream = tqlInsertion && mutateTransaction.query.insert(tqlInsertion);
+  const insertionsRes = insertionsStream ? await insertionsStream.collect() : void 0;
+  await mutateTransaction.commit();
+  await mutateTransaction.close();
+  res.rawTqlRes = { insertions: insertionsRes };
+};
+
+// src/pipeline/pipeline.ts
+var Pipelines = {
+  query: [parseBQLQuery, buildTQLQuery, runTQLQuery, parseTQLRes, dispatchPipeline],
+  mutation: [parseBQLMutation, buildTQLMutation, runTQLMutation, parseTQLRes]
+};
+var finalPipeline = [buildBQLTree];
+var runPipeline = async (pipeline, req, res = {}, root = true) => {
+  for (const operation of pipeline) {
+    const next = await operation(req, res);
+    if (next && Array.isArray(next)) {
+      for (const nextPipeline of next) {
+        await runPipeline(nextPipeline.pipeline, nextPipeline.req, nextPipeline.res, false);
+      }
+    }
+  }
+  if (root) {
+    await runPipeline(finalPipeline, req, res, false);
+    return res.bqlRes;
+  }
+};
+var queryPipeline = (bqlRequest, bormConfig, bormSchema, dbHandles) => runPipeline(
+  Pipelines.query,
+  {
+    config: bormConfig,
+    schema: bormSchema,
+    rawBqlRequest: bqlRequest,
+    dbHandles
+  },
+  {}
+);
+var mutationPipeline = (bqlRequest, bormConfig, bormSchema, dbHandles) => runPipeline(
+  Pipelines.mutation,
+  {
+    config: bormConfig,
+    schema: bormSchema,
+    rawBqlRequest: bqlRequest,
+    dbHandles
+  },
+  {}
+);
+
+// src/index.ts
+var BormClient = class {
+  schema;
+  config;
+  dbHandles;
+  constructor({ schema, config }) {
+    this.schema = schema;
+    this.config = config;
+  }
+  init = async () => {
+    const dbHandles = { typeDB: /* @__PURE__ */ new Map() };
+    const enrichedSchema = enrichSchema(this.schema);
+    await Promise.all(
+      this.config.dbConnectors.map(async (dbc) => {
+        if (dbc.provider === "typeDB" && dbc.dbName) {
+          const [clientErr, client] = await (0, import_radash9.tryit)(import_typedb_client3.TypeDB.coreClient)(dbc.url);
+          if (clientErr) {
+            const message = `[BORM:${dbc.provider}:${dbc.dbName}] ${clientErr.message ?? "Can't create TypeDB Client"}`;
+            throw new Error(message);
+          }
+          try {
+            const session = await client.session(dbc.dbName, import_typedb_client3.SessionType.DATA);
+            dbHandles.typeDB.set(dbc.id, { client, session });
+          } catch (sessionErr) {
+            const message = `[BORM:${dbc.provider}:${dbc.dbName}] ${(sessionErr.messageTemplate?._messageBody() || sessionErr.message) ?? "Can't create TypeDB Session"}`;
+            throw new Error(message);
+          }
+        }
+      })
+    );
+    this.schema = enrichedSchema;
+    this.dbHandles = dbHandles;
+  };
+  #enforceConnection = async () => {
+    if (!this.dbHandles) {
+      await this.init();
+      if (!this.dbHandles) {
+        throw new Error("Can't init BormClient");
+      }
+    }
+  };
+  introspect = async () => {
+    await this.#enforceConnection();
+    return this.schema;
+  };
+  query = async (query, queryConfig) => {
+    await this.#enforceConnection();
+    const qConfig = {
+      ...this.config,
+      query: { ...defaultConfig.query, ...this.config.query, ...queryConfig }
+    };
+    return queryPipeline(query, qConfig, this.schema, this.dbHandles);
+  };
+  mutate = async (mutation, mutationConfig) => {
+    await this.#enforceConnection();
+    const mConfig = {
+      ...this.config,
+      mutation: {
+        ...defaultConfig.mutation,
+        ...this.config.mutation,
+        ...mutationConfig
+      }
+    };
+    return mutationPipeline(mutation, mConfig, this.schema, this.dbHandles);
+  };
+  close = async () => {
+    if (!this.dbHandles) {
+      return;
+    }
+    this.dbHandles.typeDB.forEach(async ({ client, session }) => {
+      console.log("Closing session");
+      await session.close();
+      console.log("Closing client");
+      await client.close();
+    });
+  };
+};
+var src_default = BormClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});