@blitznocode/blitz-orm 0.6.4 → 0.7.0-beta

package/dist/index.mjs

@@ -1,36 +1,3306 @@
-import { tryit, mapEntries, isArray, isString, listify, flat, shake, isObject, unique, pick } from 'radash';
-import { TypeDB, SessionType, TransactionType } from 'typedb-driver';
-import { produce, current } from 'immer';
-import { traverse, getNodeByPath } from 'object-traversal';
-import { v4 } from 'uuid';
-
-var lt={query:{noMetadata:!1,simplifiedLinks:!0,debugger:!1,returnNulls:!1},mutation:{}};var Ht=s=>{let r=[],c=new Map;return s.forEach(i=>{let{dbPath:f,contentType:d}=i,a=`${f}-${d}`;c.has(a)||(c.set(a,!0),r.push(i));}),r},bt=async(s,r,c)=>{let f=(()=>{let y="",l=[];y+=`
-`,Object.keys(r.entities).forEach($=>{let g=r.entities[$],{idFields:k,dataFields:O,linkFields:F,name:q}=g,T=[],L=[],A=[];if(g.extends){let S=r.entities[g.extends];S.dataFields&&S.dataFields.forEach(E=>{T.push(E.dbPath);}),S.linkFields&&S.linkFields.forEach(E=>{L.push(E.path);}),S.idFields&&S.idFields.forEach(E=>{A.push(E);});}y+=`${q} sub ${g.extends?g.extends:"entity"},
-`;let R=[];if(k&&k.length>0){let S=new Set(k),B=Array.from(S).map(I=>`${I}`).join(", ");A.includes(B)||(y+=`    owns ${B} @key,
-`,R.push(B));}if(O&&O.length>0&&O.forEach(S=>{!T.includes(S.dbPath)&&!R.includes(S.dbPath)&&(y+=`    owns ${S.dbPath},
-`),l.push({dbPath:S.dbPath,contentType:S.contentType});}),F&&F.length>0){let S=[];F.forEach(E=>{let{relation:B,plays:I}=E;!L.includes(E.path)&&!S.includes(`${B}:${I}`)&&(y+=`    plays ${B}:${I},
-`,S.push(`${B}:${I}`));});}y=y.replace(/,\s*$/,`;
-`),y+=`
-`;}),Object.keys(r.relations).forEach($=>{let g=r.relations[$],{idFields:k,dataFields:O,roles:F,name:q,linkFields:T}=g,L=[],A=[],R=[],S=[];if(g.extends){let B=r.relations[g.extends];B.dataFields&&B.dataFields.forEach(I=>{L.push(I.dbPath);}),B.linkFields&&B.linkFields.forEach(I=>{A.push(I.dbPath);}),B.roles&&Object.values(B.roles).forEach(M=>{R.push(M.name);}),B.idFields&&B.idFields.forEach(I=>{S.push(I);});}y+=`${q} sub ${g.extends?g.extends:"relation"},
-`;let E=[];if(k&&k.length>0){let B=new Set(k),M=Array.from(B).map(P=>`${P}`).join(", ");S.includes(M)||(y+=`    owns ${M} @key,
-`,E.push(M));}if(O&&O.length>0&&O.forEach(B=>{!L.includes(B.dbPath)&&!E.includes(B.dbPath)&&(y+=`    owns ${B.dbPath},
-`),l.push({dbPath:B.dbPath,contentType:B.contentType});}),F&&Object.keys(F).forEach(B=>{R.includes(B)||(y+=`    relates ${B},
-`);}),T&&T.length>0){let B=[];T.forEach(I=>{let{plays:M}=I;!A.includes(I.path)&&!B.includes(`${g}:${M}`)&&(y+=`    plays ${I.relation}:${M},
-`,B.push(`${g}:${M}`));});}y=y.replace(/,\s*$/,`;
-`),y+=`
-`;});let t=`define
-
-`;return Ht(l).forEach($=>{t+=`${$.dbPath} sub attribute,
-`,$.contentType==="TEXT"||$.contentType==="ID"?t+=`    value string;
-`:$.contentType==="EMAIL"?(t+=`    value string,
-`,t+=`    regex '^(?=.{1,64}@)[A-Za-z0-9_-]+(\\.[A-Za-z0-9_-]+)*@[^-][A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$';
-`):$.contentType==="DATE"?t+=`    value datetime;
-`:$.contentType==="BOOLEAN"?t+=`    value boolean;
-`:$.contentType==="NUMBER"&&(t+=`    value long;
-`);}),`${t}
-
-${y}`})(),d=s.dbConnectors[0].id,a=c.typeDB.get(d)?.session,w=c.typeDB.get(d)?.client;if(!a){console.log("Session Status: ","NO SESSION");return}a.close();let[{dbName:b}]=s.dbConnectors;await(await w.databases.get(b)).delete(),await w.databases.create(b);let p=await w.session(s.dbConnectors[0].dbName,SessionType.SCHEMA),u=await p.transaction(TransactionType.WRITE);await u.query.define(f),await u.commit(),await u.close();let h=await p.transaction(TransactionType.READ),o="match $a sub thing;";(await(await h.query.match(o)).collect()).forEach(async y=>{y.get("a");}),await h.close();};var wt=(s,r,c)=>c?r:`${s}\xB7${r}`,Et=s=>{let r=s.split("\xB7");return r[r.length-1]},X=(s,r)=>Object.values(Object.fromEntries(Object.entries(s).filter(([c,i])=>r(c,i))))[0],G=(s,r)=>Object.fromEntries(Object.entries(s).filter(([c,i])=>r(c,i))),Ft=s=>{let r=[],c=produce(s,f=>traverse(f,({key:d,value:a,meta:w})=>{if(w.depth===2&&(d&&(a.dataFields=a.dataFields?.map(b=>({...b,dbPath:wt(d,b.path,b.shared)}))),a.extends)){let b=f.entities[a.extends]||f.relations[a.extends];if(a.allExtends=[a.extends,...b.allExtends||[]],a.idFields=b.idFields?(a.idFields||[]).concat(b.idFields):a.idFields,a.dataFields=b.dataFields?(a.dataFields||[]).concat(b.dataFields.map(Q=>{let p=a.extends,u=s.entities[p]||s.relations[p];for(;!u.dataFields?.find(h=>h.path===Q.path);)p=u.extends,u=s.entities[p]||s.relations[p];return {...Q,dbPath:wt(p,Q.path,Q.shared)}})):a.dataFields,a.linkFields=b.linkFields?(a.linkFields||[]).concat(b.linkFields):a.linkFields,"roles"in b){let Q=a,p=b;Q.roles=Q.roles||{},Q.roles={...Q.roles,...p.roles},Object.keys(Q.roles).length===0&&(Q.roles={});}}},{traversalType:"breadth-first"}));return traverse(s,({key:f,value:d,meta:a})=>{if(f==="linkFields"){let b=(()=>{if(!a.nodePath)throw new Error("No path");let[p,u]=a.nodePath.split(".");return {thing:u,thingType:p==="entities"?"entity":p==="relations"?"relation":""}})(),Q=Array.isArray(d)?d.map(p=>({...p,...b})):[{...d,...b}];r.push(...Q);}}),produce(c,f=>traverse(f,({value:d,key:a,meta:w})=>{if(w.depth===2&&d.idFields&&!d.id){d.name=a;let b=()=>{if(w.nodePath?.split(".")[0]==="entities")return "entity";if(w.nodePath?.split(".")[0]==="relations")return "relation";throw new Error("Unsupported node attributes")};d.thingType=b(),d.computedFields=[],d.virtualFields=[],"roles"in d&&Object.entries(d.roles).forEach(([p,u])=>{u.playedBy=r.filter(h=>h.relation===a&&h.plays===p)||[],u.name=p;}),"linkFields"in d&&d.linkFields&&d.linkFields?.forEach(p=>{if(p.target==="relation"){p.oppositeLinkFieldsPlayedBy=[{plays:p.path,thing:p.relation,thingType:"relation"}];return}let u=r.filter(o=>o.relation===p.relation&&o.plays!==p.plays)||[];p.oppositeLinkFieldsPlayedBy=u;let{filter:h}=p;p.oppositeLinkFieldsPlayedBy=p.oppositeLinkFieldsPlayedBy.filter(o=>o.target==="role"),h&&Array.isArray(h)&&(p.oppositeLinkFieldsPlayedBy=p.oppositeLinkFieldsPlayedBy.filter(o=>h.some(n=>o.thing===n.$role)),p.oppositeLinkFieldsPlayedBy=p.oppositeLinkFieldsPlayedBy.filter(o=>h.some(n=>o.thing===n.$thing))),h&&!Array.isArray(h)&&(p.oppositeLinkFieldsPlayedBy=p.oppositeLinkFieldsPlayedBy.filter(o=>o.$role===h.$role),p.oppositeLinkFieldsPlayedBy=p.oppositeLinkFieldsPlayedBy.filter(o=>o.thing===h.$thing));});}if(typeof d=="object"&&"playedBy"in d){if([...new Set(d.playedBy?.map(b=>b.thing))].length>1)throw new Error(`Unsupported: roleFields can be only played by one thing. Role: ${a} path:${w.nodePath}`);if(d.playedBy.length===0)throw new Error(`Unsupported: roleFields should be played at least by one thing. Role: ${a}, path:${w.nodePath}`)}if(w.depth===4&&(d.default||d.computedValue)){let[b,Q]=w.nodePath?.split(".")||[];d.isVirtual?f[b][Q].virtualFields.push(d.path):f[b][Q].computedFields.push(d.path);}}))},D=(s,r)=>{if(r.$entity){if(!(r.$entity in s.entities))throw new Error(`Missing entity '${r.$entity}' in the schema`);return s.entities[r.$entity]}if(r.$relation){if(!(r.$relation in s.relations))throw new Error(`Missing relation '${r.$relation}' in the schema`);return s.relations[r.$relation]}throw new Error(`Wrong schema or query for ${JSON.stringify(r)}`)},z=(s,r)=>{let c=s.dataFields?.map(n=>n.path)||[],i=s.linkFields?.map(n=>n.path)||[],f="roles"in s?listify(s.roles,n=>n):[],d=[...c||[],...i||[],...f||[]],w=[...["$entity","$op","$id","$tempId","$bzId","$relation","$parentKey","$filter","$fields","$excludedFields"],...d];if(!r)return {fields:d,dataFields:c,roleFields:f,linkFields:i};let b=r.$fields?r.$fields.map(n=>{if(typeof n=="string")return n;if("$path"in n&&typeof n.$path=="string")return n.$path;throw new Error(" Wrongly structured query")}):listify(r,n=>n),Q=r.$filter?listify(r.$filter,n=>n.toString().startsWith("$")?void 0:n.toString()).filter(n=>n&&c?.includes(n)):[],p=r.$filter?listify(r.$filter,n=>n.toString().startsWith("$")?void 0:n.toString()).filter(n=>n&&[...f||[],...i||[]].includes(n)):[],u=[...b,...Q].filter(n=>!w.includes(n)).filter(n=>n),h=r.$filter?G(r.$filter,(n,e)=>Q.includes(n)):{},o=r.$filter?G(r.$filter,(n,e)=>p.includes(n)):{};return {fields:d,dataFields:c,roleFields:f,linkFields:i,usedFields:b,usedLinkFields:i.filter(n=>b.includes(n)),usedRoleFields:f.filter(n=>b.includes(n)),unidentifiedFields:u,...Q.length?{localFilters:h}:{},...p.length?{nestedFilters:o}:{}}},Lt=(s,r)=>{let c=r.$localFilters&&listify(r.$localFilters,(f,d)=>`has ${s.dataFields?.find(w=>w.path===f)?.dbPath} '${d}'`);return c?.length?`, ${c.join(",")}`:""},U=s=>s!==null,tt=(s,r)=>Object.values(s).reduce((c,i)=>(i.extends===r&&c.push(i.name),c),[]);var ee=(s,r)=>s.map(i=>{let f=[...i.conceptMaps],a=i.owner.asThing().type.label.name,w=r.entities[a]?r.entities[a]:r.relations[a];if(!w.idFields)throw new Error(`No idFields defined for ${a}`);let b=r.entities[a]?"entity":"relation",Q=f.map(u=>{let h=u.get("attribute")?.asAttribute();return h?[Et(h.type.label.name),h.value]:[]}),p=Object.fromEntries(Q);return {...p,[`$${b}`]:a,$id:p[w.idFields[0]]}}),ne=(s,r,c)=>s.flatMap(f=>f.conceptMaps.map(a=>{let w=new Map;return r.forEach(b=>{let Q=a.get(`${b}_id`)?.asAttribute().value.toString(),p=a.get(b),u=p?.isEntity()?p.asEntity().type.label.name:p?.asRelation().type.label.name,o={id:Q,entityName:(()=>u?(c.entities[u]??c.relations[u]).allExtends?.includes(b)?b:u:b)()};Q&&w.set(b,o);}),w})),ie=(s,r,c)=>s.flatMap(f=>f.conceptMaps.map(a=>{let w=a.get(`${r}_id`)?.asAttribute().value.toString(),b=a.get(`${c}_id`)?.asAttribute().value.toString();return {ownerId:w,path:c,roleId:b}})),re=(s,r)=>{let c=listify(s.roles,(i,f)=>{if([...new Set(f.playedBy?.map(w=>w.thing))].length!==1)throw new Error("a role can be played by two entities throws the same relation");if(!f.playedBy)throw new Error("Role not being played by nobody");let d=f.playedBy[0].plays,a=tt(r.entities,d);return [d,...a]});return unique(flat(c))},J=async(s,r)=>{let{schema:c,bqlRequest:i,config:f,tqlRequest:d}=s,{rawTqlRes:a}=r;if(i){if(!a)throw new Error("TQL query not executed")}else throw new Error("BQL request not parsed");let{query:w}=i;if(!w){if(a.insertions?.length===0&&!d?.deletions){r.bqlRes={};return}let{mutation:h}=i;if(!h)throw new Error("TQL mutation not executed");let n=[...h.things,...h.edges].map(e=>{let y=a.insertions?.find(l=>l.get(`${e.$bzId}`))?.get(`${e.$bzId}`);if(e.$op==="create"||e.$op==="update"||e.$op==="link"){let l=y?.asThing().iid;return f.mutation?.noMetadata?mapEntries(e,(t,m)=>[t.toString().startsWith("$")?Symbol.for(t):t,m]):{$dbId:l,...e,[e.path]:e.$id}}if(e.$op==="delete"||e.$op==="unlink")return e;if(e.$op!=="match")throw new Error(`Unsupported op ${e.$op}`)}).filter(e=>e);r.bqlRes=n;return}if(!a.entity)throw new Error("TQL query not executed");let b=ee(a.entity,c),Q=a.relations?.map(h=>{let o=c.relations[h.relation],n=re(o,c),e=ne(h.conceptMapGroups,[...n,o.name],c);return {name:h.relation,links:e}}),p=a.roles?.map(h=>({name:h.ownerPath,links:ie(h.conceptMapGroups,h.ownerPath,h.path)})),u=r.cache||{entities:new Map,relations:new Map,roleLinks:new Map};b.forEach(h=>{let o=h.$entity||h.$relation,n=h.$id,e=u.entities.get(o)||new Map;e.set(n,{...h,$show:!0}),u.entities.set(o,e);}),Q?.forEach(h=>{let o=h.name,n=u.relations.get(o)||[];n.push(...h.links),u.relations.set(o,n),h.links.forEach(e=>{[...e.entries()].forEach(([y,{entityName:l,id:t}])=>{let m=u.entities.get(l)||new Map,g={[c.entities[l]?.thingType||c.relations[l].thingType]:l,$id:t,...m.get(t)};m.set(t,g),u.entities.set(l,m);});});}),p?.forEach(h=>{let o=c.relations[h.name]||c.entities[h.name];h.links.forEach(n=>{let e=u.roleLinks.get(n.ownerId)||{},y=e[n.path];y?isArray(y)?y.push(n.roleId):isString(y)&&y!==n.roleId&&(y=[y,n.roleId]):y=n.roleId,e[n.path]=y,u.roleLinks.set(n.ownerId,e),o.roles[n.path].playedBy?.forEach(l=>{let t=u.entities.get(l.thing)||new Map,m={$entity:l.thing,$id:n.roleId,...t.get(n.roleId)};t.set(n.roleId,m),u.entities.set(l.thing,t);});});}),r.cache=u;};var oe=/((\/\/.*$)|(\/\*.*\*\/))/gm,se=/(\s*async\s*|\s*function\s*)+/,ae=/(?:function\s*[^(\s]*\s*|\s*=>\s*|^\s*)\(([^)]*)\)/,le=/[ ,\n\r\t]+/,Rt=s=>{let r=s.toString().replace(oe,"").replace(se,"").trim(),c=ae.exec(r);if(!c)return [];let i;for(let f of c.slice(1))if(f){i=f;break}return i?(i=i.replace(/\{\s*/g,"").replace(/\s*\}/g,""),i.split(le).filter(f=>f.trim()!=="")):[]};var et=({currentThing:s,fieldSchema:r,mandatoryDependencies:c=!1})=>{if(!r||!r.default||!r.default.value)throw new Error("Virtual field: No field schema found, or wrongly configured");let i=r.default.value,d=Rt(i).filter(w=>!(w in s));if(c&&d.length)throw new Error(`Virtual field: Missing arguments ${d.join(", ")}`);return "default"in r?r.default?.value(s):void 0};var de=(s,r)=>s.length===1&&typeof s[0]!="string"&&s[0].$id===r?s[0]:s,Mt=s=>typeof s=="string"||!!s.$show,Tt=(s,r)=>produce(s,c=>traverse(c,({value:i})=>{if(Array.isArray(i)||typeof i!="object"||i===null)return;i.$tempId&&(i.$tempId=`_:${i.$tempId}`),i.$fields&&delete i.$fields,i.$filter&&delete i.$filter,i.$show&&delete i.$show,i.$bzId&&delete i.$bzId,r.query?.noMetadata&&(i.$entity||i.$relation)&&(delete i.$entity,delete i.$relation,delete i.$id),Object.getOwnPropertySymbols(i).forEach(d=>{delete i[d];}),i.$excludedFields&&(i.$excludedFields.forEach(d=>{delete i[d];}),delete i.$excludedFields);})),dt=(s,r,c,i)=>s.map(([f,d])=>{if(!r||!r.includes(f))return null;if(!c.$fields||c.$fields.includes(i))return f;let a=c.$fields.find(w=>isObject(w)&&w.$path===i);if(a){let w={...G(d,(Q,p)=>Q.startsWith("$"))},b=a.$fields?{...w,$fields:a.$fields}:w;if(a.$id){if(Array.isArray(a.$id))return a.$id.includes(f)?b:null;if(a.$id===f)return b}if(b.$fields&&b.$fields.includes("id")&&!b.$show){let Q="";return b.$fields.forEach(p=>{p==="id"?Q=b.$id:Q=b;}),Q}return b}return null}).filter(f=>f),pe=(s,r)=>{let c={};return r.forEach(i=>{c[i.$bzId]=i.$id;}),s.forEach(i=>{Object.keys(i).forEach(f=>{c[i[f]]&&f!=="$tempId"&&(i[f]=c[i[f]]);});}),s},fe=(s,r)=>{let c=r.map(f=>f.$bzId),i=!1;return s.forEach(f=>{Object.keys(f).forEach(d=>{c.includes(f[d])&&(i=!0);});}),i},qt=async(s,r)=>{let{bqlRequest:c,config:i,schema:f}=s,{cache:d}=r;if(!c)throw new Error("BQL request not parsed");let{query:a}=c;if(!a){let y=r.bqlRes[0]?r.bqlRes:[r.bqlRes],l=s.bqlRequest?.mutation?.things;if(fe(y,l)){let $=pe(y,l);r.bqlRes=$[1]?$:$[0];}let m=Tt(r.bqlRes,i);r.bqlRes=m;return}if(!d)return;let w="$entity"in a?a.$entity:a.$relation,b=d.entities.get(w.name);if(!b){r.bqlRes=null;return}let p=listify(a.$filter,y=>y).some(y=>w.dataFields?.find(l=>l.path===y)?.validations?.unique),u=!Array.isArray(c.query)&&(c.query?.$id&&!Array.isArray(c.query?.$id)||p);if(Array.isArray(s.rawBqlRequest))throw new Error("Query arrays not implemented yet");let h=b,o=[...h].length?[...h].map(([y,l])=>({...s.rawBqlRequest,$id:y})):s.rawBqlRequest,n=produce(o,y=>traverse(y,({value:l})=>{let t=l;if(!t?.$entity&&!t?.$relation)return;let m="$entity"in t?t.$entity:t.$relation;if(m){let $=Array.isArray(t.$id)?t.$id:[t.$id],g="$relation"in t?f.relations[t.$relation]:f.entities[t.$entity],{dataFields:k,roleFields:O,fields:F}=z(g);i.query?.returnNulls&&(t.$fields?t.$fields.map(A=>typeof A=="string"?A:A.$path):F).forEach(A=>{t[A]=null;});let q=d.entities.get(m);if(!q)return;[...q].forEach(([L,A])=>{if($.includes(L)){let R=t.$fields?t.$fields:k,{virtualFields:S}=g;S?.forEach(M=>{if(R?.includes(M)&&(t[M]===void 0||t[M]===null)){let P=g.dataFields?.find(x=>x.path===M),C=et({currentThing:A,fieldSchema:P});t[M]=C;}}),listify(A,(M,P)=>{M.startsWith("$")||R?.includes(M)&&(t[M]=P);});let E=d.roleLinks.get(L),B=t.$fields?t.$fields.filter(M=>typeof M=="string"):O,I=t.$fields?.filter(M=>typeof M=="object")?.map(M=>M.$path)||[];Object.entries(E||{}).forEach(([M,P])=>{if(![...B,...I].includes(M))return;if(!("roles"in g))throw new Error("No roles in schema");let C=Array.isArray(P)?[...new Set(P)]:[P],{cardinality:x,playedBy:v}=g.roles[M],j=[...new Set(v?.map(V=>V.thing))]?.flatMap(V=>{let Y=d.entities.get(V);return Y?dt([...Y],C,t,M):[]});if(j?.length){if(j.length===1&&j[0]===t.$id)return;if(x==="ONE"){t[M]=j[0];return}t[M]=j.filter(V=>typeof V=="string"||typeof V=="object"&&V?.$show);}});}});let T=g.linkFields;T&&T.forEach(L=>{let A=d.relations.get(L.relation),R=L.oppositeLinkFieldsPlayedBy;if(!A)return null;if(L.target==="relation"){let S=[...A].reduce((E,B)=>{let I=B.get(L.plays)?.id;if(I&&I===$[0]){let M=B.get(L.relation);if(!M)return E;E[M.entityName]||(E[M.entityName]=new Set),E[M.entityName].add(M.id);}return E},{});return Object.entries(S).map(([E,B])=>{let I=d.entities.get(E);if(!I)return null;let M=dt([...I],[...B.values()],t,L.path).filter(U).filter(Mt);if(M.length===0)return null;if(M&&M.length){if(L.cardinality==="ONE")return t[L.path]=M[0],null;t[L.path]=M;}return null}),null}return L.target==="role"&&R.forEach(S=>{if(!A)return;let E=[...A].reduce((B,I)=>{let M=I.get(L.plays)?.id;if(M&&M===$[0]){let P=I.get(S.plays);if(!P)return B;B[P.entityName]||(B[P.entityName]=new Set),B[P.entityName].add(P.id);}return B},{});Object.entries(E).forEach(([B,I])=>{let M=d.entities.get(B);if(!M)return;let P=dt([...M],[...I.values()],t,L.path).filter(U).filter(Mt);if(P.length!==0&&P&&P.length){if(L.cardinality==="ONE"){t[L.path]=P[0];return}t[L.path]=P;let C={},x=N=>(N.$path===L.path&&(C=N),N?.$fields?.forEach(x)),v="";a.$fields?.forEach(x),C&&(Array.isArray(C.$id)||(v=C.$id)),t[L.path]=de(P,v);}});}),null});}})),e=Tt(n,i);r.bqlRes=u?e[0]:e;};var nt=async s=>{let{schema:r,bqlRequest:c}=s;if(!c?.query)throw new Error("BQL query not parsed");let{query:i}=c,f="$entity"in i?i.$entity:i.$relation,d=f.defaultDBConnector.path||f.name;if(!d)throw new Error(`No thing path in ${JSON.stringify(f)}`);if(!f.idFields)throw new Error("No id fields");let[a]=f.idFields,w=`$${d}_id`,b=`, has ${a} ${w};`;i.$id&&(Array.isArray(i.$id)?b+=` ${w} like "${i.$id.join("|")}";`:b+=` ${w} "${i.$id}";`);let Q=Lt(f,i),p="roles"in f?listify(f.roles,(n,e)=>({path:n,var:`$${n}`,schema:e})):[],u=`match $${d}  isa ${d}, has attribute $attribute ${Q} ${b} get; group $${d};`,h=p.map(n=>{if(!n.schema.playedBy||[...new Set(n.schema.playedBy?.map(y=>y.thing))].length!==1)throw new Error("Unsupported: Role played by multiple linkfields or none");let e=n.schema.playedBy[0].thing;return {path:n.path,owner:d,request:`match $${d} (${n.path}: ${n.var} ) isa ${d} ${b} ${n.var} isa ${e}, has id ${n.var}_id; get; group $${d};`}}),o=f.linkFields?.flatMap(n=>{let e=`$${n.plays}_id`,y=`, has ${a} ${e};`;i.$id&&(Array.isArray(i.$id)?y+=` ${e} like "${i.$id.join("|")}";`:y+=` ${e} "${i.$id}";`);let l=`match $${n.plays} isa ${d}${Q} ${y}`,t=n.target==="relation",$=`$${n.relation}`,g=`${t?$:""} (${n.plays}: $${n.plays}`,k=n.oppositeLinkFieldsPlayedBy.map(R=>t?null:`${R.plays}: $${R.plays}`),O=[g,...k].filter(R=>R).join(",");if(r.relations[n.relation]===void 0)throw new Error(`Relation ${n.relation} not found in schema`);let F=r.relations[n.relation].defaultDBConnector.path||n.relation,q=`) isa ${F};`,T=n.oppositeLinkFieldsPlayedBy.map(R=>`$${t?R.thing:R.plays} isa ${R.thing}, has id $${t?R.thing:R.plays}_id;`).join(" "),L=`get; group $${n.plays};`,A=`${l} ${O} ${q} ${T} ${L}`;return {relation:F,entity:d,request:A}});s.tqlRequest={entity:u,...h?.length?{roles:h}:{},...o?.length?{relations:o}:{}};};var Ot=async s=>{let{rawBqlRequest:r,schema:c}=s;if(!("$entity"in r)&&!("$relation"in r))throw new Error("No entity specified in query");let i=D(c,r);if(!i)throw new Error(`Thing '${r}' not found in schema`);let{unidentifiedFields:f,localFilters:d,nestedFilters:a}=z(i,r);if(f&&f.length>0)throw new Error(`Unknown fields: [${f.join(",")}] in ${JSON.stringify(r)}`);s.bqlRequest={query:{...s.rawBqlRequest,...i.thingType==="entity"?{$entity:i}:{},...i.thingType==="relation"?{$relation:i}:{},...d?{$localFilters:d}:{},...a?{$nestedFilters:a}:{}}};};var it=async(s,r)=>{let c=r.dbConnectors[0].id,i=s.typeDB.get(c)?.session,f=s.typeDB.get(c)?.client;if(!i||!i.isOpen()){if(!f)throw new Error("Client not found");i=await f.session(r.dbConnectors[0].dbName,SessionType.DATA),s.typeDB.set(c,{client:f,session:i});}return {client:f,session:i}};var rt=async(s,r)=>{let{dbHandles:c,bqlRequest:i,tqlRequest:f,config:d}=s;if(!i)throw new Error("BQL request not parsed");if(!f)throw new Error("TQL request not built");if(!f.entity)throw new Error("BQL request error, no entities");let{query:a}=i;if(!a)throw new Error("BQL request is not a query");let{session:w}=await it(c,d),b=await w.transaction(TransactionType.READ);if(!b)throw new Error("Can't create transaction");let Q=b.query.getGroup(f.entity),p=f.roles?.map(e=>({...e,stream:b.query.getGroup(e.request)})),u=f.relations?.map(e=>({...e,stream:b.query.getGroup(e.request)})),h=await Q.collect(),o=await Promise.all(p?.map(async e=>({path:e.path,ownerPath:e.owner,conceptMapGroups:await e.stream.collect()}))||[]),n=await Promise.all(u?.map(async e=>({relation:e.relation,entity:e.entity,conceptMapGroups:await e.stream.collect()}))||[]);await b.close(),r.rawTqlRes={entity:h,...o?.length&&{roles:o},...n?.length&&{relations:n}};};var pt=async(s,r)=>{let{bqlRequest:c,schema:i}=s,{cache:f}=r;if(!c)throw new Error("BQL request not parsed");if(!f)throw new Error("Cache not initialized");let{query:d}=c;if(!d)return;let{$fields:a}=d;if(!("$entity"in d)&&!("$relation"in d))throw new Error("Node attributes not supported");let w="$entity"in d?d.$entity:d.$relation;if(!a||!Array.isArray(a))return;let b=a.filter(o=>typeof o!="string"&&o.$path),Q=w.linkFields?.filter(o=>b.findIndex(n=>n.$path===o.path)!==-1).flatMap(o=>o.oppositeLinkFieldsPlayedBy)||[],p="roles"in w?listify(w.roles,(o,n)=>b.findIndex(e=>e.$path===o)!==-1?n:null).flatMap(o=>o?.playedBy).filter(o=>o):[],h=[...Q,...p]?.map(o=>{if(!o)return null;let{thing:n}=o,e=tt(i.entities,n);return [n,...e].map(y=>{let l=f.entities.get(y);if(!l)return null;let t=Array.from(l.values()).reduce((T,L)=>("$show"in L||T.push(L.$id),T),[]);if(t.length===0)return null;let m=i.entities[y]?{...i.entities[y],thingType:"entity"}:{...i.relations[y],thingType:"relation"},$=a.find(T=>typeof T=="object"&&T.$path===o.plays),g=$?.$id,k=g?Array.isArray(g)?g:[g]:[],O=$?.$filter,q={query:{$id:k.length?k.filter(T=>t.includes(T)):t,$fields:$?.$fields,...m.thingType==="entity"?{$entity:m}:{},...m.thingType==="relation"?{$relation:m}:{},...O?{$localFilters:O}:{}}};return {req:{...s,bqlRequest:q},res:r,pipeline:[nt,rt,J,pt]}}).filter(U)}).filter(U);if(h?.length)return flat(h)};var At=async s=>{let{bqlRequest:r,schema:c}=s;if(!r)throw new Error("BQL request not parsed");let{mutation:i}=r;if(!i)throw new Error("BQL request is not a mutation");let f=o=>{let n=o.$op,e=`$${o.$bzId}`,y=D(c,o),{idFields:l,defaultDBConnector:t}=y,m=t?.path||o.$entity||o.$relation,$=o.$id,g=l?.[0],k=listify(o,(E,B)=>{if(E.startsWith("$")||E===g||B===void 0||B===null)return "";let I=y.dataFields?.find(C=>C.path===E);if(!I?.path)return "";let P=I.dbPath;if(["TEXT","ID","EMAIL"].includes(I.contentType))return `has ${P} '${B}'`;if(["NUMBER","BOOLEAN"].includes(I.contentType))return `has ${P} ${B}`;if(I.contentType==="DATE"){if(Number.isNaN(B.valueOf()))throw new Error("Invalid format, Nan Date");return B instanceof Date?`has ${P} ${B.toISOString().replace("Z","")}`:`has ${P} ${new Date(B).toISOString().replace("Z","")}`}throw new Error(`Unsupported contentType ${I.contentType}`)}).filter(E=>E),O=`${e}-atts`,F=listify(o,E=>{if(E.startsWith("$")||E===g)return "";let B=y.dataFields?.find(P=>P.path===E);if(!B?.path)return "";let M=B.dbPath;return `{${O} isa ${M};}`}).filter(E=>E),q=o[Symbol.for("isLocalId")],T=isArray($)?`like '${$.join("|")}'`:`'${$}'`,L=!q&&$?[`has ${g} ${T}`]:[],A=[...L,...k].filter(E=>E).join(","),R=()=>{if(n==="delete"||n==="unlink"||n==="match")return `${e} isa ${[m,...L].filter(E=>E).join(",")};`;if(n==="update"){if(!F.length)throw new Error("update without attributes");return `${e} isa ${[m,...L].filter(E=>E).join(",")}, has ${O};
-        ${F.join(" or ")};`}return ""},S=()=>n==="update"||n==="link"||n==="match"?`${e} isa ${[m,...L].filter(E=>E).join(",")};`:"";if(o.$entity||o.$relation)return {op:n,deletionMatch:R(),insertionMatch:S(),insertion:n==="create"?`${e} isa ${[m,A].filter(E=>E).join(",")};`:n==="update"&&k.length?`${e} ${k.join(",")};`:"",deletion:n==="delete"?`${e} isa ${m};`:n==="update"&&F.length?`${e} has ${O};`:""};throw new Error("in attributes")},d=o=>{let n=o.$op,e=D(c,o),y=`$${o.$bzId}`,l=o.$id,t=e.defaultDBConnector?.path||o.$relation,m="roles"in e?listify(e.roles,S=>S):[],$=o.$relation&&"roles"in e&&mapEntries(e.roles,(S,E)=>[S,E.dbConnector?.path||S]),g=listify(o,(S,E)=>{if(!m.includes(S))return null;if(!("roles"in e))throw new Error("This should have roles! ");let B=$[S];return Array.isArray(E)?E.map(I=>({path:B,id:I})):{path:B,id:E}}).filter(S=>S).flat(),k=g.map(S=>{if(!S?.path)throw new Error("Object without path");return `${S.path}: $${S.id}`}),O=g.length>0?`( ${k.join(" , ")} )`:"",F=O?`${y} ${O} ${o[Symbol.for("edgeType")]==="linkField"||n==="delete"||n==="unlink"?`isa ${t}`:""}`:"",q=`${y}  ${o[Symbol.for("edgeType")]==="linkField"||n==="delete"?`isa ${t}`:""}`,T=()=>F?n==="link"?`${F};`:n==="create"?`${F}, has id '${l}';`:"":"",L=()=>F&&n==="match"?`${F};`:"",A=()=>F?n==="delete"?`${F};`:n==="match"?`${F};`:"":"",R=()=>F?n==="delete"?`${q};`:n==="unlink"?`${y} ${O};`:"":"";return {deletionMatch:A(),insertionMatch:L(),deletion:R(),insertion:T(),op:""}},a=(o,n)=>{let e=n==="edges"?d:f;if(Array.isArray(o))return o.map(g=>{let{preDeletionBatch:k,insertionMatch:O,deletionMatch:F,insertion:q,deletion:T}=e(g);return shake({preDeletionBatch:k,insertionMatch:O,deletionMatch:F,insertion:q,deletion:T},L=>!L)}).filter(g=>g);let{preDeletionBatch:y,insertionMatch:l,deletionMatch:t,insertion:m,deletion:$}=e(o);return shake({preDeletionBatch:y,insertionMatch:l,deletionMatch:t,insertion:m,deletion:$},g=>!g)},w=a(i.things),b=Array.isArray(w)?w:[w],Q=a(i.edges,"edges"),p=Array.isArray(Q)?Q:[Q],u=[...b,...p],h=shake({insertionMatches:u.map(o=>o.insertionMatch).join(" ").trim(),deletionMatches:u.map(o=>o.deletionMatch).join(" ").trim(),insertions:u.map(o=>o.insertion).join(" ").trim(),deletions:u.map(o=>o.deletion).join(" ").trim()},o=>!o);s.tqlRequest=h;};var Re=s=>{if(!s.startsWith("_:"))throw new Error("ID must start with '_:'.");let r=s.substring(2);if(!/^[a-zA-Z0-9-_]+$/.test(r))throw new Error("$tempId must contain only alphanumeric characters, hyphens, and underscores.");if(s.length>36)throw new Error("$tempId must not be longer than 36 characters.");return r},kt=async s=>{let{rawBqlRequest:r,schema:c}=s,f=(Q=>produce(Q,p=>traverse(p,({value:u,key:h,parent:o})=>{isObject(u)&&(u=shake(u,n=>n===void 0)),h==="$tempId"&&(o[h]=Re(u));})))(r),a=(Q=>produce(Q,p=>traverse(p,({value:u,meta:h,key:o})=>{if(isObject(u)){if(u.$arrayOp)throw new Error("Array op not supported yet");if(o==="$filter"||h.nodePath?.includes(".$filter."))return;let n=u;if(n.$op==="create"&&n.$id)throw new Error("Can't write to computed field $id. Try writing to the id field directly.");let e=D(c,n),l=h.nodePath?.split(".")?.filter(F=>Number.isNaN(parseInt(F,10))).join(".");if(!e)throw new Error(`Schema not found for ${n.$entity||n.$relation}`);n.$bzId=n.$tempId??`T_${v4()}`,n[Symbol.for("schema")]=e,n[Symbol.for("dbId")]=e.defaultDBConnector.id;let{usedLinkFields:t,usedRoleFields:m}=z(e,n),$=t.map(F=>({fieldType:"linkField",path:F,schema:e.linkFields.find(q=>q.path===F)})),g=e.thingType==="relation"?m.map(F=>({fieldType:"roleField",path:F,schema:X(e.roles,q=>q===F)})):[];if($.some(F=>F.schema?.target==="role")&&$.some(F=>F.schema?.target==="relation"))throw new Error("Unsupported: Can't use a link field with target === 'role' and another with target === 'relation' in the same mutation.");let k=g.filter(F=>[...new Set(F.schema.playedBy?.map(q=>q.thing))].length!==1);if(k.length>1)throw new Error(`Field: ${k[0].path} - If a role can be played by multiple things, you must specify the thing in the mutation: ${JSON.stringify(k[0].schema.playedBy)}. Schema: ${JSON.stringify(k[0].schema)}`);let O=h.nodePath;if([...$,...g].forEach(F=>{let q=n[F.path];if(q===void 0)return;let T=F.schema;if(!T)throw new Error(`Field ${F.path} not found in schema`);let L=F.fieldType==="roleField"?T?.playedBy[0]:T,R=(()=>T&&"relation"in T&&L?.relation===n.$relation?"$self":L?.relation?L?.relation:"$self")(),S=R==="$self"?e:c.relations[R];if(X(S.roles,(C,x)=>C===F.path)?.playedBy?.length===0)throw new Error(`unused role: ${O}.${F.path}`);if(!T)throw new Error(`Field ${F.path} not found in schema`);let B=F.fieldType==="linkField"?T?.oppositeLinkFieldsPlayedBy:T?.playedBy;if(!B)throw new Error(`No opposite fields found for ${JSON.stringify(T)}`);if([...new Set(B?.map(C=>C.thing))].length>1)throw new Error(`Field: ${F.path} - If a role can be played by multiple things, you must specify the thing in the mutation: ${JSON.stringify(B)}. Schema: ${JSON.stringify(T)}`);if(T.cardinality==="ONE"&&Array.isArray(q))throw new Error("Can't have an array in a cardinality === ONE link field");if(T.cardinality==="MANY"&&q!==null&&!Array.isArray(q)&&!q.$arrayOp)throw new Error(`${F.fieldType==="linkField"?T.path:T.name} is a cardinality === MANY thing. Use an array or a $arrayOp object`);if(q?.$entity||q?.$relation)return;let[I]=B,M="plays"in T?"linkField":"roleField",P={[`$${I.thingType}`]:I.thing,[Symbol.for("relation")]:R,[Symbol.for("edgeType")]:M,[Symbol.for("parent")]:{path:O,...n.$id?{$id:n.$id}:{},...n.$tempId?{$tempId:n.$tempId}:{},...n.filter?{filter:n.filter}:{},links:B},[Symbol.for("role")]:I.plays,[Symbol.for("oppositeRole")]:"plays"in T?T.plays:void 0,[Symbol.for("relFieldSchema")]:T};if(isObject(q)&&(n[F.path]={...P,...q}),Array.isArray(q))if(q.every(C=>isObject(C)))n[F.path]=q.map(C=>({...P,...C}));else if(q.every(C=>typeof C=="string"))n[F.path]=q.map(C=>({...P,$op:n.$op==="create"?"link":"replace",$id:C}));else throw new Error(`Invalid array value for ${F.path}`);if(typeof q=="string"&&(n[F.path]={...P,$op:n.$op==="create"?"link":"replace",$id:q}),q===null){let C={...P,$op:"unlink"};n[F.path]=T.cardinality==="MANY"?[C]:C;}}),!l&&!n.$entity&&!n.$relation)throw new Error("Root things must specify $entity or $relation")}})))(f),b=(Q=>produce(Q,p=>traverse(p,({parent:u,key:h,value:o,meta:n})=>{if(isObject(o)){if(Object.keys(o).length===0)throw new Error("Empty object!");if(h==="$filter"||n.nodePath?.includes(".$filter."))return;let e=o,y=n.nodePath?.split(".");if(e.$tempId&&!(e.$op===void 0||e.$op==="link"||e.$op==="create"||e.$op==="update"))throw new Error(`Invalid op ${e.$op} for tempId. TempIds can be created, or when created in another part of the same mutation. In the future maybe we can use them to catch stuff in the DB as well and group them under the same tempId.`);let l=y?.filter(N=>Number.isNaN(parseInt(N,10))).join("."),t=l?Array.isArray(u)?y?.slice(0,-1).join("."):n.nodePath:n.nodePath||"",m=D(c,e),{unidentifiedFields:$,dataFields:g,roleFields:k,linkFields:O}=z(m,e),F=current(e)[Symbol.for("parent")],q=l&&F.path,L=(q?getNodeByPath(p,q):p)?.$op;if(l&&!L)throw new Error("Error: Parent $op not detected");let A=e[Symbol.for("relFieldSchema")];e.$op==="replace"&&L==="create"&&(e.$op="link");let R=Object.keys(e).some(N=>g?.includes(N)),S=Object.keys(e).some(N=>[...k,...O].includes(N)),E=()=>{if(e.$op)return e.$op;if(l&&!e.$id&&!e.$tempId&&L!=="create"&&A.cardinality==="ONE")throw new Error(`Please specify if it is a create or an update. Path: ${n.nodePath}`);if(e.$tempId)return "create";if((e.$id||e.$filter)&&R)return "update";if((e.$id||e.$filter)&&l&&!R&&!S)return "link";if(!e.$filter&&!e.$id&&!e.$tempId)return "create";if((e.$id||e.$filter)&&!R&&S)return "match";throw new Error("Wrong op")};if(e.$op||(e.$op=E()),u||(e.$parentKey=""),typeof u=="object"&&(Array.isArray(u)&&(e[Symbol.for("index")]=h),e[Symbol.for("path")]=t,e[Symbol.for("isRoot")]=!l,e[Symbol.for("depth")]=l?.split(".").length),!e.$entity&&!e.$relation)throw new Error(`Node ${JSON.stringify(e)} without $entity/$relation`);let{idFields:B,computedFields:I,virtualFields:M}=m;if(!B)throw new Error("No idFields found");let[P]=B,C=listify(e,(N,j)=>j!==void 0?N:void 0),x=C.filter(N=>M?.includes(N));if(x.length>0)throw new Error(`Virtual fields can't be sent to DB: "${x.join(",")}"`);if(I.filter(N=>!C.includes(N)).forEach(N=>{let j=m.dataFields?.find(_=>_.path===N),Y=m.linkFields?.find(_=>_.path===N)?.oppositeLinkFieldsPlayedBy[0],Ut="roles"in m?X(m.roles,(_,ke)=>_===N):void 0,$t=j||Y||Ut;if(!$t)throw new Error(`no field Def for ${N}`);if(N===P&&e.$op==="create"&&!e[N]){let _=et({currentThing:e,fieldSchema:$t,mandatoryDependencies:!0});e[N]=_,e.$id=_;}}),$.length>0)throw new Error(`Unknown fields: [${$.join(",")}] in ${JSON.stringify(e)}`)}})))(a);s.filledBqlRequest=b;};var Dt=async s=>{let{filledBqlRequest:r,schema:c}=s,i=p=>{let u=[],h=[],o=l=>{if(l.$id)return l.$id;let t=D(c,l),{idFields:m}=t;if(!m)throw new Error(`no idFields: ${JSON.stringify(l)}`);let[$]=m;if(!$)throw new Error(`no idField: ${JSON.stringify(l)}`);let g=t.dataFields?.find(F=>F.path===$),k=l.$op==="create"?g?.default?.value():null,O=l[$]||l.$id||k;if(!O)throw new Error(`no idValue: ${JSON.stringify(l)}`);return O},n=l=>{if(l.$op==="create"){let t=o(l);if(u.find(m=>m.$id===t))throw new Error(`Duplicate id ${t} for node ${JSON.stringify(l)}`);if(h.find(m=>m.$bzId===l.$bzId))throw new Error(`Duplicate $bzid ${l.$bzId} for node ${JSON.stringify(l)}`);u.push({...l,$id:t});return}l.$tempId&&l.$op==="match"||u.push(l);},e=l=>{if(l.$op==="create"){let t=o(l);if(u.find(m=>m.$id===t),h.find(m=>m.$bzId===l.$bzId))throw new Error(`Duplicate %bzId ${l.$bzIdd} for edge ${JSON.stringify(l)}`);h.push({...l,$id:t});return}h.push(l);};return traverse(p,({value:l})=>{if(!isObject(l))return;let t=l;if(t.$entity||t.$relation){if(!t.$op)throw new Error(`Operation should be defined at this step ${JSON.stringify(t)}`);if(!t.$bzId)throw new Error("[internal error] BzId not found");let m=D(c,t),{dataFields:$,roleFields:g,linkFields:k,usedFields:O}=z(m,t),F=()=>{if(t.$op==="create"||t.$op==="delete")return t.$op;if(t.$op==="update"){let T=O.filter(R=>$?.includes(R)),L=O.filter(R=>g?.includes(R)),A=O.filter(R=>k?.includes(R));if(T.length>0)return "update";if(L.length>0||A.length>0)return "match";throw new Error(`No fields on an $op:"update" for node ${JSON.stringify(t)}`)}return "match"},q={...t.$entity&&{$entity:t.$entity},...t.$relation&&{$relation:t.$relation},...t.$id&&{$id:t.$id},...t.$tempId&&{$tempId:t.$tempId},...t.$filter&&{$filter:t.$filter},...shake(pick(t,$||[""])),$op:F(),$bzId:t.$bzId,[Symbol.for("dbId")]:m.defaultDBConnector.id,[Symbol.for("path")]:t[Symbol.for("path")],[Symbol.for("parent")]:t[Symbol.for("parent")],[Symbol.for("isRoot")]:t[Symbol.for("isRoot")],[Symbol.for("isLocalId")]:t[Symbol.for("isLocalId")]||!1};if(n(q),t[Symbol.for("relation")]&&t[Symbol.for("edgeType")]==="linkField"){if((t.$op==="link"||t.$op==="unlink")&&(t.$id||t.$filter)){if(t.$tempId)throw new Error("can't specify a existing and a new element at once. Use an id/filter or a tempId");u.push({...t,$op:"match"});}let T=t[Symbol.for("relation")]===t.$relation,L=T?t.$bzId:v4(),R=t[Symbol.for("parent")].path,E=(R?getNodeByPath(p,R):p).$bzId;if(!E)throw new Error("No parent id found");if(t[Symbol.for("relation")]==="$self")return;let B=()=>{if(t.$op==="delete")return T?"match":"delete";if(t.$op==="unlink")return T?"unlink":"delete";if(t.$op==="link"||t.$op==="create")return T?"link":"create";if(t.$op==="replace")throw new Error("Unsupported: Nested replaces not implemented yet");return "match"},I={$relation:t[Symbol.for("relation")],$bzId:L,...t.$tempId?{$tempId:t.$tempId}:{},$op:B(),...T?{}:{[t[Symbol.for("role")]]:t.$bzId},[t[Symbol.for("oppositeRole")]]:E,[Symbol.for("dbId")]:c.relations[t[Symbol.for("relation")]].defaultDBConnector.id,[Symbol.for("edgeType")]:"linkField",[Symbol.for("info")]:"normal linkField",[Symbol.for("path")]:t[Symbol.for("path")],[Symbol.for("parent")]:t[Symbol.for("parent")]};e(I),(t.$op==="unlink"||B()==="unlink")&&T&&e({$relation:t[Symbol.for("relation")],$bzId:L,$op:"match",[t[Symbol.for("oppositeRole")]]:E,[Symbol.for("dbId")]:c.relations[t[Symbol.for("relation")]].defaultDBConnector.id,[Symbol.for("edgeType")]:"linkField",[Symbol.for("info")]:"additional ownrelation unlink linkField",[Symbol.for("path")]:t[Symbol.for("path")],[Symbol.for("parent")]:t[Symbol.for("parent")]});}if(t.$relation){let T=G(t,(R,S)=>g.includes(R)),L=mapEntries(T,(R,S)=>isArray(S)?[R,S]:isObject(S)?[R,S.$bzId]:[R,S]),A=G(l,(R,S)=>R.startsWith("$")||R.startsWith("Symbol"));if(Object.keys(T).filter(R=>!R.startsWith("$")).length>0){if(t.$op==="create"||t.$op==="delete"){let R=()=>{if(t.$op==="create")return "link";if(t.$op==="delete")return "match";throw new Error("Unsupported parent of edge op")},S=mapEntries(L,(B,I)=>Array.isArray(I)?[B,I.map(M=>M.$bzId||M)]:[B,I.$bzId||I]),E={...A,$relation:t.$relation,$op:R(),...S,$bzId:t.$bzId,[Symbol.for("path")]:t[Symbol.for("path")],[Symbol.for("dbId")]:m.defaultDBConnector.id,[Symbol.for("info")]:"coming from created or deleted relation",[Symbol.for("edgeType")]:"roleField on C/D"};e(E);return}if(t.$op==="match"||t.$op==="update"&&Object.keys(T).length>0){let R=0;Object.entries(T).forEach(([S,E])=>{let B=isArray(E)?E:[E],I=M=>M==="create"||M==="replace"?"link":M;B.forEach(M=>{let P=I(M.$op);if(P==="replace")throw new Error("Not supported yet: replace on roleFields");if(P==="unlink"&&R>0)throw R+=1,new Error("Not supported yet: Cannot unlink more than one role at a time, please split into two mutations");let C={...A,$relation:t.$relation,$op:P==="delete"?"unlink":P,[S]:M.$bzId,$bzId:t.$bzId,[Symbol.for("dbId")]:m.defaultDBConnector.id,[Symbol.for("parent")]:t[Symbol.for("parent")],[Symbol.for("path")]:t[Symbol.for("path")],[Symbol.for("info")]:"updating roleFields",[Symbol.for("edgeType")]:"roleField on L/U/R"};e(C);});});}}}}}),[u,h]};if(!r)throw new Error("Undefined filledBqlRequest");let [f,d]=i(r),a=f.reduce((p,u)=>{if(!u.$bzId)return [...p,u];let h=p.findIndex(o=>o.$bzId===u.$bzId);if(h===-1)return [...p,u];if(p[h].$op==="create"&&u.$op==="match")return p;if(p[h].$op==="match"&&(u.$op==="create"||u.$op==="match"))return [...p.slice(0,h),u,...p.slice(h+1)];throw new Error(`Unsupported operation combination for $tempId "${u.$tempId}". Existing: ${p[h].$op}. Current: ${u.$op}`)},[]),w=d.reduce((p,u)=>{let h=p.find(o=>(o.$id&&o.$id===u.$id||o.$bzId&&o.$bzId===u.$bzId)&&o.$relation===u.$relation&&o.$op===u.$op);if(h){let o={...h};return Object.keys(u).forEach(e=>{if(typeof e=="symbol"||e.startsWith("$"))return;let y=h[e],l=u[e];Array.isArray(y)&&Array.isArray(l)?o[e]=Array.from(new Set([...y,...l])):!Array.isArray(y)&&Array.isArray(l)?y!==void 0?o[e]=Array.from(new Set([y,...l])):o[e]=l:Array.isArray(y)&&!Array.isArray(l)?l!==void 0&&(o[e]=Array.from(new Set([...y,l]))):y||(o[e]=l);}),[...p.filter(e=>!((e.$id&&e.$id===u.$id||e.$bzId&&e.$bzId===u.$bzId)&&e.$relation===u.$relation&&e.$op===u.$op)),o]}return [...p,u]},[]);[...new Set(w.map(p=>p.$relation))];s.bqlRequest={mutation:{things:a,edges:w}};};var xt=async s=>{let{filledBqlRequest:r}=s;if(Array.isArray(r))return;let i=r,d=(e=>{if(Array.isArray(e)){let y=[],l=null,t=null;if(traverse(e,({value:$,key:g,meta:k})=>{k.depth===2&&(g==="$relation"?l=$:g==="$entity"?t=$:g==="$id"&&typeof $=="string"&&y.push($));}),!l&&!t)throw new Error("Neither $relation nor $entity found in the blocks");let m={$id:y};return l&&(m.$relation=l),t&&(m.$entity=t),m}else if(isObject(e)){let y={...e.$relation&&{$relation:e.$relation},...e.$entity&&{$entity:e.$entity},$id:e.$id||e.id};return traverse(e,({key:l,value:t,meta:m})=>{if(l==="$op"&&t==="match"&&m.nodePath){let $=m.nodePath.split(".").slice(0,-1),g=y;$.forEach(k=>{g.$fields||(g.$fields=[]);let O=g.$fields.find(F=>F.$path===k);O||(O={$path:k},g.$fields.push(O)),g=O;});}}),y}return e})(r),a=await st(d,s.config,s.schema,s.dbHandles),w=(e,y)=>{let l=e.$id||e.id||e.$bzId;return `${e.$objectPath?l?e.$objectPath:e.$objectPath.split(".")[0]:"root"}${l?`-${l}`:""}.${y}`},Q=a?(e=>produce(e,y=>traverse(y,l=>{let{key:t,parent:m}=l;m&&t&&!t.includes("$")&&(Array.isArray(m[t])?m[t].forEach($=>{typeof $!="string"&&($.$objectPath=w(m,t));}):isObject(m[t])&&(m[t].$objectPath=w(m,t)));})))(a):{},p={};(e=>produce(e,y=>traverse(y,l=>{let{key:t,parent:m}=l;if(m&&t&&m.$id&&!t.includes("$")){let $=w(m,t);if(Array.isArray(m[t])){let g=[];m[t].forEach(k=>{isObject(k)?g.push(k.$id.toString()):g.push(k.toString());}),p[$]=g;}else {let g=m[t];isObject(g)?p[$]=g.$id.toString():p[$]=g.toString();}}})))(Q);let h=(e,y)=>{let l=!1,t=Array.isArray(p[e])?"MANY":"ONE",m=Array.isArray(p[e])?p[e]:[p[e]];return m&&(l=(Array.isArray(y)?m.filter(g=>y.includes(g)):m.filter(g=>g===y)).length>0),{found:l,cardinality:t,isOccupied:!!p[e]}},o=(e,y)=>{let l=[],t=Array.isArray(p[e])?p[e]:[p[e]],m=y.map($=>$.$id);return t&&(l=t.filter($=>!m.includes($))),l};a&&(i=(e=>produce(e,y=>traverse(y,l=>{let{key:t,value:m,parent:$}=l;if($&&t&&!t.includes("$")&&(Array.isArray(m)||isObject(m))&&!Array.isArray($)&&(Array.isArray($[t])?$[t].forEach(g=>{typeof g!="string"&&(g.$objectPath=w($,t));}):isObject($[t])&&($[t].$objectPath=w($,t))),t&&$&&!t?.includes("$")&&(Array.isArray(m)||isObject(m))&&!Array.isArray($)){let g=Array.isArray(m)?m:[m],k={},O=[],F=[],q=w($,t);g.forEach(L=>{let A=L.$id||L.id,{found:R,cardinality:S,isOccupied:E}=h(q,A);if(L.$op&&A)switch(L.$op){case"delete":if(!R)throw new Error(`[BQLE-Q-M-2] Cannot delete $id:"${A}" because it is not linked to $id:"${$.$id}"`);break;case"update":if(!R)throw new Error(`[BQLE-Q-M-2] Cannot update $id:"${A}" because it is not linked to $id:"${$.$id}"`);break;case"unlink":if(!R)throw new Error(`[BQLE-Q-M-2] Cannot unlink $id:"${A}" because it is not linked to $id:"${$.$id}"`);break;case"link":if(R)throw new Error(`[BQLE-Q-M-2] Cannot link $id:"${A}" because it is already linked to $id:"${$.$id}"`);break;case"replace":O.push(L),L.$op="link",R&&F.push(A);break;case"create":O.push(L);break;}else if(L.$op==="link"&&!R&&S==="ONE"&&E)throw new Error(`[BQLE-Q-M-2] Cannot link on:"${L.$objectPath}" because it is already occupied.`)}),O.length>0&&o(q,O).forEach(A=>{let R=g.find(E=>E.$id===A&&E.$op==="link"),[S]=O;if(S.$entity?k.$entity=S.$entity:S.$relation&&(k.$relation=S.$relation),!R&&!g.some(E=>E.$id===A)){let E={...k,$op:"unlink",$id:A,$bzId:`T_${v4()}`};Array.isArray(m)?m.push(E):g=[m,E];}else if(R){let E=g.findIndex(B=>B.$id===A&&B.$op==="link");E>-1&&g.splice(E,1);}});let T=g.filter(L=>!F.includes(L.$id));$[t]=isObject(m)&&T.length===1?T[0]:T;}})))(i),s.filledBqlRequest=i);};var jt=async(s,r)=>{let{dbHandles:c,tqlRequest:i,bqlRequest:f,config:d}=s;if(!i)throw new Error("TQL request not built");if(!(i.deletions&&i.deletionMatches||i.insertions))throw new Error("TQL request error, no things");if(!f?.mutation)throw new Error("BQL mutation not parsed");let{session:a}=await it(c,d),w=await a.transaction(TransactionType.WRITE);if(!w)throw new Error("Can't create transaction");let b=i.deletionMatches&&i.deletions&&`match ${i.deletionMatches} delete ${i.deletions}`,Q=i.insertions&&`${i.insertionMatches?`match ${i.insertionMatches}`:""} insert ${i.insertions}`;b&&w.query.delete(b);let p=Q&&w.query.insert(Q);try{let u=p?await p.collect():void 0;await w.commit(),await w.close(),r.rawTqlRes={insertions:u};}catch(u){throw await w.close(),new Error(`Transaction failed: ${u.message}`)}};var zt={query:[Ot,nt,rt,J,pt],mutation:[kt,xt,Dt,At,jt,J]},Ae=[qt],at=async(s,r,c={},i=!0)=>{for(let f of s){let d=await f(r,c);if(d&&Array.isArray(d))for(let a of d)await at(a.pipeline,a.req,a.res,!1);}return i?(await at(Ae,r,c,!1),r.config.query?.debugger===!0&&typeof c.bqlRes=="object"?{...c.bqlRes,$debugger:{tqlRequest:r.tqlRequest}}:c.bqlRes):c.bqlRes},st=(s,r,c,i)=>at(zt.query,{config:r,schema:c,rawBqlRequest:s,dbHandles:i},{}),Vt=(s,r,c,i)=>at(zt.mutation,{config:r,schema:c,rawBqlRequest:s,dbHandles:i},{});var mt=class{schema;config;dbHandles;constructor({schema:r,config:c}){this.schema=r,this.config=c;}init=async()=>{let r={typeDB:new Map},c=Ft(this.schema);await Promise.all(this.config.dbConnectors.map(async i=>{if(i.provider==="typeDB"&&i.dbName){let[f,d]=await tryit(TypeDB.coreDriver)(i.url);if(f){let a=`[BORM:${i.provider}:${i.dbName}:core] ${f.message??"Can't create TypeDB Client"}`;throw new Error(a)}try{let a=await d.session(i.dbName,SessionType.DATA);r.typeDB.set(i.id,{client:d,session:a});}catch(a){let w=`[BORM:${i.provider}:${i.dbName}:session] ${(a.messageTemplate?._messageBody()||a.message)??"Can't create TypeDB Session"}`;throw new Error(w)}}if(i.provider==="typeDBCluster"&&i.dbName){let[f,d]=await tryit(TypeDB.enterpriseDriver)(i.addresses,i.credentials);if(f){let a=`[BORM:${i.provider}:${i.dbName}:core] ${f.message??"Can't create TypeDB Cluster Client"}`;throw new Error(a)}try{let a=await d.session(i.dbName,SessionType.DATA);r.typeDB.set(i.id,{client:d,session:a});}catch(a){let w=`[BORM:${i.provider}:${i.dbName}:session] ${(a.messageTemplate?._messageBody()||a.message)??"Can't create TypeDB Session"}`;throw new Error(w)}}})),this.schema=c,this.dbHandles=r;};#t=async()=>{if(!this.dbHandles&&(await this.init(),!this.dbHandles))throw new Error("Can't init BormClient")};introspect=async()=>(await this.#t(),this.schema);define=async()=>(await this.#t(),bt(this.config,this.schema,this.dbHandles));query=async(r,c)=>{await this.#t();let i={...this.config,query:{...lt.query,...this.config.query,...c}};return st(r,i,this.schema,this.dbHandles)};mutate=async(r,c)=>{await this.#t();let i={...this.config,mutation:{...lt.mutation,...this.config.mutation,...c}};return Vt(r,i,this.schema,this.dbHandles)};close=async()=>{this.dbHandles&&this.dbHandles.typeDB.forEach(async({client:r,session:c})=>{console.log("Closing session"),await c.close(),console.log("Closing client"),await r.close();});}},Ii=mt;//! reads all the insertions and gets the first match. This means each id must be unique
-//! disabled as it has false positives
+// src/index.ts
+import { tryit } from "radash";
+import { TypeDB, SessionType as SessionType3 } from "typedb-driver";
+
+// src/default.config.ts
+var defaultConfig = {
+  query: {
+    noMetadata: false,
+    simplifiedLinks: true,
+    debugger: false,
+    returnNulls: false
+  },
+  mutation: {
+    noMetadata: false,
+    preQuery: true,
+    ignoreNonexistingThings: false
+  }
+};
+
+// src/define/index.ts
+import { SessionType, TransactionType } from "typedb-driver";
+var removeDuplicateObjects = (arr) => {
+  const uniqueObjects = [];
+  const uniqueMap = /* @__PURE__ */ new Map();
+  arr.forEach((obj) => {
+    const { dbPath, contentType } = obj;
+    const key = `${dbPath}-${contentType}`;
+    if (!uniqueMap.has(key)) {
+      uniqueMap.set(key, true);
+      uniqueObjects.push(obj);
+    }
+  });
+  return uniqueObjects;
+};
+var bormDefine = async (config, schema, dbHandles) => {
+  const convertSchema = () => {
+    let output = "";
+    const usedAttributes = [];
+    output += "\n";
+    Object.keys(schema.entities).forEach((entityName) => {
+      const entity = schema.entities[entityName];
+      const { idFields, dataFields, linkFields, name } = entity;
+      const commonDataFields = [];
+      const commonLinkFields = [];
+      const commonIdFields = [];
+      if (entity.extends) {
+        const parentEntity = schema.entities[entity.extends];
+        if (parentEntity.dataFields) {
+          parentEntity.dataFields.forEach((dataField) => {
+            commonDataFields.push(dataField.dbPath);
+          });
+        }
+        if (parentEntity.linkFields) {
+          parentEntity.linkFields.forEach((linkField) => {
+            commonLinkFields.push(linkField.path);
+          });
+        }
+        if (parentEntity.idFields) {
+          parentEntity.idFields.forEach((idField) => {
+            commonIdFields.push(idField);
+          });
+        }
+      }
+      output += `${name} sub ${entity.extends ? entity.extends : "entity"},
+`;
+      const idsAsData = [];
+      if (idFields && idFields.length > 0) {
+        const setIds = new Set(idFields);
+        const newIdFields = Array.from(setIds);
+        const idFieldsString = newIdFields.map((field) => `${field}`).join(", ");
+        if (!commonIdFields.includes(idFieldsString)) {
+          output += `    owns ${idFieldsString} @key,
+`;
+          idsAsData.push(idFieldsString);
+        }
+      }
+      if (dataFields && dataFields.length > 0) {
+        dataFields.forEach((field) => {
+          if (!commonDataFields.includes(field.dbPath) && !idsAsData.includes(field.dbPath)) {
+            output += `    owns ${field.dbPath},
+`;
+          }
+          usedAttributes.push({ dbPath: field.dbPath, contentType: field.contentType });
+        });
+      }
+      if (linkFields && linkFields.length > 0) {
+        const usedLinkFields = [];
+        linkFields.forEach((linkField) => {
+          const { relation, plays } = linkField;
+          if (!commonLinkFields.includes(linkField.path) && !usedLinkFields.includes(`${relation}:${plays}`)) {
+            output += `    plays ${relation}:${plays},
+`;
+            usedLinkFields.push(`${relation}:${plays}`);
+          }
+        });
+      }
+      output = output.replace(/,\s*$/, ";\n");
+      output += "\n";
+    });
+    Object.keys(schema.relations).forEach((relationName) => {
+      const relation = schema.relations[relationName];
+      const { idFields, dataFields, roles, name, linkFields } = relation;
+      const commonDataFields = [];
+      const commonLinkFields = [];
+      const commonRoleFields = [];
+      const commonIdFields = [];
+      if (relation.extends) {
+        const parentRelation = schema.relations[relation.extends];
+        if (parentRelation.dataFields) {
+          parentRelation.dataFields.forEach((dataField) => {
+            commonDataFields.push(dataField.dbPath);
+          });
+        }
+        if (parentRelation.linkFields) {
+          parentRelation.linkFields.forEach((linkField) => {
+            commonLinkFields.push(linkField.dbPath);
+          });
+        }
+        if (parentRelation.roles) {
+          const roleFields = Object.values(parentRelation.roles);
+          roleFields.forEach((roleField) => {
+            commonRoleFields.push(roleField.name);
+          });
+        }
+        if (parentRelation.idFields) {
+          parentRelation.idFields.forEach((idField) => {
+            commonIdFields.push(idField);
+          });
+        }
+      }
+      output += `${name} sub ${relation.extends ? relation.extends : "relation"},
+`;
+      const idsAsData = [];
+      if (idFields && idFields.length > 0) {
+        const setIds = new Set(idFields);
+        const newIdFields = Array.from(setIds);
+        const idFieldsString = newIdFields.map((field) => `${field}`).join(", ");
+        if (!commonIdFields.includes(idFieldsString)) {
+          output += `    owns ${idFieldsString} @key,
+`;
+          idsAsData.push(idFieldsString);
+        }
+      }
+      if (dataFields && dataFields.length > 0) {
+        dataFields.forEach((field) => {
+          if (!commonDataFields.includes(field.dbPath) && !idsAsData.includes(field.dbPath)) {
+            output += `    owns ${field.dbPath},
+`;
+          }
+          usedAttributes.push({ dbPath: field.dbPath, contentType: field.contentType });
+        });
+      }
+      if (roles) {
+        Object.keys(roles).forEach((roleName) => {
+          if (!commonRoleFields.includes(roleName)) {
+            output += `    relates ${roleName},
+`;
+          }
+        });
+      }
+      if (linkFields && linkFields.length > 0) {
+        const usedLinkFields = [];
+        linkFields.forEach((linkField) => {
+          const { plays } = linkField;
+          if (!commonLinkFields.includes(linkField.path) && !usedLinkFields.includes(`${relation}:${plays}`)) {
+            output += `    plays ${linkField.relation}:${plays},
+`;
+            usedLinkFields.push(`${relation}:${plays}`);
+          }
+        });
+      }
+      output = output.replace(/,\s*$/, ";\n");
+      output += "\n";
+    });
+    let attributes = "define\n\n";
+    const newUsedAttributes = removeDuplicateObjects(usedAttributes);
+    newUsedAttributes.forEach((attribute) => {
+      attributes += `${attribute.dbPath} sub attribute,
+`;
+      if (attribute.contentType === "TEXT" || attribute.contentType === "ID") {
+        attributes += "    value string;\n";
+      } else if (attribute.contentType === "EMAIL") {
+        attributes += "    value string,\n";
+        attributes += "    regex '^(?=.{1,64}@)[A-Za-z0-9_-]+(\\.[A-Za-z0-9_-]+)*@[^-][A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*(\\.[A-Za-z]{2,})$';\n";
+      } else if (attribute.contentType === "DATE") {
+        attributes += "    value datetime;\n";
+      } else if (attribute.contentType === "BOOLEAN") {
+        attributes += "    value boolean;\n";
+      } else if (attribute.contentType === "NUMBER") {
+        attributes += "    value long;\n";
+      }
+    });
+    return `${attributes}
+
+${output}`;
+  };
+  const typeDBString = convertSchema();
+  const singleHandlerV0 = config.dbConnectors[0].id;
+  const session = dbHandles.typeDB.get(singleHandlerV0)?.session;
+  const client = dbHandles.typeDB.get(singleHandlerV0)?.client;
+  if (!session) {
+    console.log("Session Status: ", "NO SESSION");
+    return;
+  }
+  session.close();
+  const [{ dbName }] = config.dbConnectors;
+  const db = await client.databases.get(dbName);
+  await db.delete();
+  await client.databases.create(dbName);
+  const schemaSession = await client.session(config.dbConnectors[0].dbName, SessionType.SCHEMA);
+  const schemaTransaction = await schemaSession.transaction(TransactionType.WRITE);
+  await schemaTransaction.query.define(typeDBString);
+  await schemaTransaction.commit();
+  await schemaTransaction.close();
+  const getSchemaTransaction = await schemaSession.transaction(TransactionType.READ);
+  const getSchemaQuery = "match $a sub thing;";
+  const getSchemaStream = await getSchemaTransaction.query.match(getSchemaQuery);
+  const schemaThings = await getSchemaStream.collect();
+  schemaThings.forEach(async (conceptMap) => {
+    const thing = conceptMap.get("a");
+    const { _label } = thing;
+    const { _name } = _label;
+  });
+  await getSchemaTransaction.close();
+};
+
+// src/helpers.ts
+import { produce } from "immer";
+import { traverse } from "object-traversal";
+import { listify } from "radash";
+var getDbPath = (thing, attribute, shared) => shared ? attribute : `${thing}\xB7${attribute}`;
+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 = produce(
+    schema,
+    (draft) => 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.allExtends = [value.extends, ...extendedSchema.allExtends || []];
+          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" }
+    )
+  );
+  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 = produce(
+    withExtensionsSchema,
+    (draft) => 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 = [];
+        value.virtualFields = [];
+        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) || [];
+            role.name = 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) => (
+                  // @ts-expect-error - TODO description
+                  filter.some((ft) => lf.thing === ft.$role)
+                )
+              );
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                (lf) => (
+                  // @ts-expect-error - TODO description
+                  filter.some((ft) => lf.thing === ft.$thing)
+                )
+              );
+            }
+            if (filter && !Array.isArray(filter)) {
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                // @ts-expect-error - TODO description
+                (lf) => lf.$role === filter.$role
+              );
+              linkField.oppositeLinkFieldsPlayedBy = linkField.oppositeLinkFieldsPlayedBy.filter(
+                // @ts-expect-error - TODO description
+                (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(".") || [];
+        if (value.isVirtual) {
+          draft[type][thingId].virtualFields.push(value.path);
+        } else {
+          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, null, 2)}`);
+};
+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 ? listify(currentSchema.roles, (k) => k) : [];
+  const availableFields = [
+    ...availableDataFields || [],
+    ...availableLinkFields || [],
+    ...availableRoleFields || []
+  ];
+  const reservedRootFields = [
+    "$entity",
+    "$op",
+    "$id",
+    "$tempId",
+    "$bzId",
+    "$relation",
+    "$parentKey",
+    "$filter",
+    "$fields",
+    "$excludedFields"
+  ];
+  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 && typeof x.$path === "string") {
+      return x.$path;
+    }
+    throw new Error(" Wrongly structured query");
+  }) : listify(node, (k) => k);
+  const localFilterFields = !node.$filter ? [] : listify(node.$filter, (k) => k.toString().startsWith("$") ? void 0 : k.toString()).filter(
+    (x) => x && availableDataFields?.includes(x)
+  );
+  const nestedFilterFields = !node.$filter ? [] : 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)).filter((x) => 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,
+    usedFields,
+    usedLinkFields: availableLinkFields.filter((x) => usedFields.includes(x)),
+    usedRoleFields: availableRoleFields.filter((x) => usedFields.includes(x)),
+    unidentifiedFields,
+    ...localFilterFields.length ? { localFilters } : {},
+    ...nestedFilterFields.length ? { nestedFilters } : {}
+  };
+};
+var notNull = (value) => {
+  return value !== null;
+};
+
+// src/pipeline/postprocess/parseTQLMutation.ts
+import { mapEntries } from "radash";
+var parseTQLMutation = async (req, res) => {
+  const { 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) {
+      res.bqlRes = {};
+      return;
+    }
+    const { mutation } = bqlRequest;
+    if (!mutation) {
+      throw new Error("TQL mutation not executed");
+    }
+    const expected = [...mutation.things, ...mutation.edges];
+    const result = expected.map((exp) => {
+      const currentNode = rawTqlRes.insertions?.find((y) => y.get(`${exp.$bzId}`))?.get(`${exp.$bzId}`);
+      if (exp.$op === "create" || exp.$op === "update" || exp.$op === "link") {
+        const dbIdd = currentNode?.asThing().iid;
+        if (config.mutation?.noMetadata) {
+          return mapEntries(exp, (k, v) => [
+            k.toString().startsWith("$") ? Symbol.for(k) : k,
+            v
+          ]);
+        }
+        return { $dbId: dbIdd, ...exp, ...{ [exp.path]: exp.$id } };
+      }
+      if (exp.$op === "delete" || exp.$op === "unlink") {
+        return exp;
+      }
+      if (exp.$op === "match") {
+        return void 0;
+      }
+      throw new Error(`Unsupported op ${exp.$op}`);
+    }).filter((z) => z);
+    res.bqlRes = result;
+    return;
+  }
+};
+
+// src/pipeline/postprocess/fieldsOperator.ts
+import { isObject } from "radash";
+
+// src/pipeline/postprocess/buildBQLTree.ts
+import { produce as produce2 } from "immer";
+import { traverse as traverse2 } from "object-traversal";
+import { isObject as isObject2, listify as listify2 } from "radash";
+
+// src/engine/helpers.ts
+var STRIP_COMMENTS = /((\/\/.*$)|(\/\*.*\*\/))/gm;
+var STRIP_KEYWORDS = /(\s*async\s*|\s*function\s*)+/;
+var ARGUMENT_NAMES = /(?:function\s*[^(\s]*\s*|\s*=>\s*|^\s*)\(([^)]*)\)/;
+var ARGUMENT_SPLIT = /[ ,\n\r\t]+/;
+var getParamNames = (func) => {
+  const fnStr = func.toString().replace(STRIP_COMMENTS, "").replace(STRIP_KEYWORDS, "").trim();
+  const matches = ARGUMENT_NAMES.exec(fnStr);
+  if (!matches) {
+    return [];
+  }
+  let match;
+  for (const matchGroup of matches.slice(1)) {
+    if (matchGroup) {
+      match = matchGroup;
+      break;
+    }
+  }
+  if (!match) {
+    return [];
+  }
+  match = match.replace(/\{\s*/g, "").replace(/\s*\}/g, "");
+  return match.split(ARGUMENT_SPLIT).filter((part) => part.trim() !== "");
+};
+
+// src/engine/compute.ts
+var compute = ({
+  currentThing,
+  fieldSchema,
+  mandatoryDependencies = false
+}) => {
+  if (!fieldSchema || !fieldSchema.default || !fieldSchema.default.value) {
+    throw new Error("Virtual field: No field schema found, or wrongly configured");
+  }
+  const fn = fieldSchema.default.value;
+  const args = getParamNames(fn);
+  const missingArgs = args.filter((arg) => !(arg in currentThing));
+  if (mandatoryDependencies && missingArgs.length) {
+    throw new Error(`Virtual field: Missing arguments ${missingArgs.join(", ")}`);
+  }
+  const computedValue = "default" in fieldSchema ? fieldSchema.default?.value(currentThing) : void 0;
+  return computedValue;
+};
+
+// src/pipeline/postprocess/buildBQLTree.ts
+var isOne = (children, $id) => {
+  if (children.length === 1 && typeof children[0] !== "string" ? children[0].$id === $id : false) {
+    return children[0];
+  }
+  return children;
+};
+var isStringOrHasShow = (value) => {
+  return typeof value === "string" || !!value.$show;
+};
+var cleanOutput = (obj, config) => produce2(
+  obj,
+  (draft) => traverse2(draft, ({ value }) => {
+    if (Array.isArray(value) || !(typeof value === "object") || value === null) {
+      return;
+    }
+    if (value.$tempId) {
+      value.$tempId = `_:${value.$tempId}`;
+    }
+    if (value.$fields) {
+      delete value.$fields;
+    }
+    if (value.$filter) {
+      delete value.$filter;
+    }
+    if (value.$show) {
+      delete value.$show;
+    }
+    if (value.$bzId) {
+      delete value.$bzId;
+    }
+    if (config.query?.noMetadata && (value.$entity || value.$relation)) {
+      delete value.$entity;
+      delete value.$relation;
+      delete value.$id;
+    }
+    const symbols = Object.getOwnPropertySymbols(value);
+    symbols.forEach((symbol) => {
+      delete value[symbol];
+    });
+    if (value.$excludedFields) {
+      value.$excludedFields.forEach((field) => {
+        delete value[field];
+      });
+      delete value.$excludedFields;
+    }
+  })
+);
+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) => isObject2(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;
+      }
+    }
+    if (withFieldsEntity.$fields && withFieldsEntity.$fields.includes("id") && !withFieldsEntity.$show) {
+      let returnVal = "";
+      withFieldsEntity.$fields.forEach((field) => {
+        if (field === "id") {
+          returnVal = withFieldsEntity.$id;
+        } else {
+          returnVal = withFieldsEntity;
+        }
+      });
+      return returnVal;
+    }
+    return withFieldsEntity;
+  }
+  return null;
+}).filter((x) => x);
+var replaceBzIds = (resItems, things) => {
+  const mapping = {};
+  things.forEach((thing) => {
+    mapping[thing.$bzId] = thing.$id;
+  });
+  resItems.forEach((item) => {
+    Object.keys(item).forEach((key) => {
+      if (mapping[item[key]] && key !== "$tempId") {
+        item[key] = mapping[item[key]];
+      }
+    });
+  });
+  return resItems;
+};
+var hasMatches = (resItems, things) => {
+  const bzIds = things.map((thing) => thing.$bzId);
+  let found = false;
+  resItems.forEach((item) => {
+    Object.keys(item).forEach((key) => {
+      if (bzIds.includes(item[key])) {
+        found = true;
+      }
+    });
+  });
+  return found;
+};
+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) {
+    const resItems = res.bqlRes[0] ? res.bqlRes : [res.bqlRes];
+    const things = req.bqlRequest?.mutation?.things;
+    const matchesFound = hasMatches(resItems, things);
+    if (matchesFound) {
+      const replaced = replaceBzIds(resItems, things);
+      res.bqlRes = replaced[1] ? replaced : replaced[0];
+    }
+    const output = cleanOutput(res.bqlRes, config);
+    res.bqlRes = output;
+    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 = listify2(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 = produce2(
+    structuredAnswer,
+    (draft) => traverse2(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, fields } = getCurrentFields(currentSchema);
+        if (config.query?.returnNulls) {
+          const queriedPaths = value.$fields ? value.$fields.map((x) => typeof x === "string" ? x : x.$path) : fields;
+          queriedPaths.forEach((path) => {
+            value[path] = null;
+          });
+        }
+        const currentEntities = cache.entities.get(thingName);
+        if (!currentEntities) {
+          return;
+        }
+        [...currentEntities].forEach(([id, entity]) => {
+          if (currentIds.includes(id)) {
+            const queriedDataFields = value.$fields ? value.$fields : dataFields;
+            const { virtualFields } = currentSchema;
+            virtualFields?.forEach((virtualField) => {
+              if (queriedDataFields?.includes(virtualField) && // @ts-expect-error - No need to compute if it was received somehow from the DB or if it is not a virtual field
+              (value[virtualField] === void 0 || value[virtualField] === null)) {
+                const fieldSchema = currentSchema.dataFields?.find((x) => x.path === virtualField);
+                const computedValue = compute({ currentThing: entity, fieldSchema });
+                value[virtualField] = computedValue;
+              }
+            });
+            listify2(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 (!currentRelation) {
+              return null;
+            }
+            if (linkField.target === "relation") {
+              const linkedEntities = [...currentRelation].reduce((acc, relation) => {
+                const id = relation.get(linkField.plays)?.id;
+                if (id && id === currentIds[0]) {
+                  const opposingRole = relation.get(linkField.relation);
+                  if (!opposingRole) {
+                    return acc;
+                  }
+                  if (!acc[opposingRole.entityName]) {
+                    acc[opposingRole.entityName] = /* @__PURE__ */ new Set();
+                  }
+                  acc[opposingRole.entityName].add(opposingRole.id);
+                }
+                return acc;
+              }, {});
+              Object.entries(linkedEntities).map(([key, linkedEntityVal]) => {
+                const allCurrentLinkFieldThings = cache.entities.get(key);
+                if (!allCurrentLinkFieldThings) {
+                  return null;
+                }
+                const children = filterChildrenEntities(
+                  [...allCurrentLinkFieldThings],
+                  [...linkedEntityVal.values()],
+                  value,
+                  linkField.path
+                ).filter(notNull).filter(isStringOrHasShow);
+                if (children.length === 0) {
+                  return null;
+                }
+                if (children && children.length) {
+                  if (linkField.cardinality === "ONE") {
+                    value[linkField.path] = children[0];
+                    return null;
+                  }
+                  value[linkField.path] = children;
+                }
+                return null;
+              });
+              return null;
+            }
+            if (linkField.target === "role") {
+              tunnel.forEach((t) => {
+                if (!currentRelation) {
+                  return;
+                }
+                const linkedEntities = [...currentRelation].reduce((acc, relation) => {
+                  const id = relation.get(linkField.plays)?.id;
+                  if (id && id === currentIds[0]) {
+                    const opposingRole = relation.get(t.plays);
+                    if (!opposingRole) {
+                      return acc;
+                    }
+                    if (!acc[opposingRole.entityName]) {
+                      acc[opposingRole.entityName] = /* @__PURE__ */ new Set();
+                    }
+                    acc[opposingRole.entityName].add(opposingRole.id);
+                  }
+                  return acc;
+                }, {});
+                Object.entries(linkedEntities).forEach(([key, linkedEntityVal]) => {
+                  const allCurrentLinkFieldThings = cache.entities.get(key);
+                  if (!allCurrentLinkFieldThings) {
+                    return;
+                  }
+                  const children = filterChildrenEntities(
+                    [...allCurrentLinkFieldThings],
+                    [...linkedEntityVal.values()],
+                    value,
+                    linkField.path
+                  ).filter(notNull).filter(isStringOrHasShow);
+                  if (children.length === 0) {
+                    return;
+                  }
+                  if (children && children.length) {
+                    if (linkField.cardinality === "ONE") {
+                      value[linkField.path] = children[0];
+                      return;
+                    }
+                    value[linkField.path] = children;
+                    let filtered = {};
+                    const filterFunc = (o) => {
+                      if (o.$path === linkField.path) {
+                        filtered = o;
+                      }
+                      return o?.$fields?.forEach(filterFunc);
+                    };
+                    let pathAndIdMatch = "";
+                    query.$fields?.forEach(filterFunc);
+                    if (filtered) {
+                      if (!Array.isArray(filtered.$id)) {
+                        pathAndIdMatch = filtered.$id;
+                      }
+                    }
+                    value[linkField.path] = isOne(children, pathAndIdMatch);
+                  }
+                });
+              });
+            }
+            return null;
+          });
+        }
+      }
+    })
+  );
+  const withoutFieldFilters = cleanOutput(bqlTree, config);
+  res.bqlRes = monoOutput ? withoutFieldFilters[0] : withoutFieldFilters;
+};
+
+// src/pipeline/preprocess/buildTQLMutation.ts
+import { isArray, listify as listify3, mapEntries as mapEntries2, shake } from "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 bzId = `$${node.$bzId}`;
+    const currentSchema = getCurrentSchema(schema, node);
+    const { idFields, defaultDBConnector } = currentSchema;
+    const thingDbPath = defaultDBConnector?.path || node.$entity || node.$relation;
+    const idValue = node.$id;
+    const idField = idFields?.[0];
+    const attributes = listify3(node, (k, v) => {
+      if (k.startsWith("$") || k === idField || v === void 0 || v === null) {
+        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", "BOOLEAN"].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 = `${bzId}-atts`;
+    const matchAttributes = listify3(node, (k) => {
+      if (k.startsWith("$") || k === idField) {
+        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 isLocalId = node[Symbol.for("isLocalId")];
+    const idValueTQL = isArray(idValue) ? `like '${idValue.join("|")}'` : `'${idValue}'`;
+    const idAttributes = !isLocalId && idValue ? (
+      // if it is a relation, add only the id fields in the lines where we add the roles also so it does not get defined twice
+      [`has ${idField} ${idValueTQL}`]
+    ) : [];
+    const allAttributes = [...idAttributes, ...attributes].filter((x) => x).join(",");
+    const getDeletionMatchInNodes = () => {
+      if (op === "delete" || op === "unlink" || op === "match") {
+        return `${bzId} isa ${[thingDbPath, ...idAttributes].filter((x) => x).join(",")};`;
+      }
+      if (op === "update") {
+        if (!matchAttributes.length) {
+          throw new Error("update without attributes");
+        }
+        return `${bzId} isa ${[thingDbPath, ...idAttributes].filter((x) => x).join(",")}, has ${attributesVar};
+        ${matchAttributes.join(" or ")};`;
+      }
+      return "";
+    };
+    const getInsertionMatchInNodes = () => {
+      if (op === "update" || op === "link" || op === "match") {
+        return `${bzId} isa ${[thingDbPath, ...idAttributes].filter((x) => x).join(",")};`;
+      }
+      return "";
+    };
+    if (node.$entity || node.$relation) {
+      return {
+        op,
+        deletionMatch: getDeletionMatchInNodes(),
+        insertionMatch: getInsertionMatchInNodes(),
+        insertion: op === "create" ? `${bzId} isa ${[thingDbPath, allAttributes].filter((x) => x).join(",")};` : op === "update" && attributes.length ? `${bzId} ${attributes.join(",")};` : "",
+        deletion: op === "delete" ? `${bzId} isa ${thingDbPath};` : op === "update" && matchAttributes.length ? `${bzId} has ${attributesVar};` : ""
+      };
+    }
+    throw new Error("in attributes");
+  };
+  const edgeToTypeQL = (node) => {
+    const op = node.$op;
+    const currentSchema = getCurrentSchema(schema, node);
+    const bzId = `$${node.$bzId}`;
+    const idValue = node.$id;
+    const relationDbPath = currentSchema.defaultDBConnector?.path || node.$relation;
+    const roleFields = "roles" in currentSchema ? listify3(currentSchema.roles, (k) => k) : [];
+    const roleDbPaths = node.$relation && "roles" in currentSchema && mapEntries2(currentSchema.roles, (k, v) => [k, v.dbConnector?.path || k]);
+    const fromRoleFields = listify3(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) => {
+      if (!x?.path) {
+        throw new Error("Object without path");
+      }
+      return `${x.path}: $${x.id}`;
+    });
+    const roles = fromRoleFields.length > 0 ? `( ${fromRoleFieldsTql.join(" , ")} )` : "";
+    const relationTql = !roles ? "" : `${bzId} ${roles} ${node[Symbol.for("edgeType")] === "linkField" || op === "delete" || op === "unlink" ? `isa ${relationDbPath}` : ""}`;
+    const relationTqlWithoutRoles = `${bzId}  ${node[Symbol.for("edgeType")] === "linkField" || op === "delete" ? `isa ${relationDbPath}` : ""}`;
+    const getInsertionsInEdges = () => {
+      if (!relationTql) {
+        return "";
+      }
+      if (op === "link") {
+        return `${relationTql};`;
+      }
+      if (op === "create") {
+        return `${relationTql}, has id '${idValue}';`;
+      }
+      return "";
+    };
+    const getInsertionMatchInEdges = () => {
+      if (!relationTql) {
+        return "";
+      }
+      if (op === "match") {
+        return `${relationTql};`;
+      }
+      return "";
+    };
+    const getDeletionMatchInEdges = () => {
+      if (!relationTql) {
+        return "";
+      }
+      if (op === "delete") {
+        return `${relationTql};`;
+      }
+      if (op === "unlink") {
+      }
+      if (op === "match") {
+        return `${relationTql};`;
+      }
+      return "";
+    };
+    const getDeletionsInEdges = () => {
+      if (!relationTql) {
+        return "";
+      }
+      if (op === "delete") {
+        return `${relationTqlWithoutRoles};`;
+      }
+      if (op === "unlink") {
+        return `${bzId} ${roles};`;
+      }
+      return "";
+    };
+    return {
+      // preDeletionBatch: getPreDeletionBatch(),
+      deletionMatch: getDeletionMatchInEdges(),
+      insertionMatch: getInsertionMatchInEdges(),
+      deletion: getDeletionsInEdges(),
+      insertion: getInsertionsInEdges(),
+      op: ""
+    };
+  };
+  const toTypeQL = (nodes, mode) => {
+    const typeQL = mode === "edges" ? edgeToTypeQL : nodeToTypeQL;
+    if (Array.isArray(nodes)) {
+      return nodes.map((x) => {
+        const { preDeletionBatch: preDeletionBatch2, insertionMatch: insertionMatch2, deletionMatch: deletionMatch2, insertion: insertion2, deletion: deletion2 } = typeQL(x);
+        return shake({ preDeletionBatch: preDeletionBatch2, insertionMatch: insertionMatch2, deletionMatch: deletionMatch2, insertion: insertion2, deletion: deletion2 }, (z) => !z);
+      }).filter((y) => y);
+    }
+    const { preDeletionBatch, insertionMatch, deletionMatch, insertion, deletion } = typeQL(nodes);
+    return shake({ preDeletionBatch, 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 = shake(
+    {
+      // preDeletionBatch: allOperations.flatMap((x) => x.preDeletionBatch).filter((y) => y !== undefined),
+      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()
+      // ...(typeQLRelations?.length && { relations: typeQLRelations }),
+    },
+    (x) => !x
+  );
+  req.tqlRequest = tqlRequest;
+};
 
-export { Ii as default };
+// src/pipeline/preprocess/fill.ts
+import { produce as produce3, current } from "immer";
+import { traverse as traverse3, getNodeByPath } from "object-traversal";
+import { isObject as isObject3, listify as listify4, shake as shake2 } from "radash";
+import { v4 as uuidv4 } from "uuid";
+var sanitizeTempId = (id) => {
+  if (!id.startsWith("_:")) {
+    throw new Error("ID must start with '_:'.");
+  }
+  const sanitizedId = id.substring(2);
+  if (!/^[a-zA-Z0-9-_]+$/.test(sanitizedId)) {
+    throw new Error("$tempId must contain only alphanumeric characters, hyphens, and underscores.");
+  }
+  if (id.length > 36) {
+    throw new Error("$tempId must not be longer than 36 characters.");
+  }
+  return sanitizedId;
+};
+var fillBQLMutation = async (req) => {
+  const { rawBqlRequest, schema } = req;
+  const shakeBqlRequest = (blocks) => {
+    return produce3(
+      blocks,
+      (draft) => traverse3(draft, ({ value: val, key, parent }) => {
+        if (isObject3(val)) {
+          val = shake2(val, (att) => att === void 0);
+        }
+        if (key === "$tempId") {
+          parent[key] = sanitizeTempId(val);
+        }
+      })
+    );
+  };
+  const shakedBqlRequest = shakeBqlRequest(rawBqlRequest);
+  const stringToObjects = (blocks) => {
+    return produce3(
+      blocks,
+      (draft) => traverse3(draft, ({ value: val, meta, key }) => {
+        if (isObject3(val)) {
+          if (val.$arrayOp) {
+            throw new Error("Array op not supported yet");
+          }
+          if (key === "$filter" || meta.nodePath?.includes(".$filter.")) {
+            return;
+          }
+          const value = val;
+          if (value.$op === "create" && value.$id) {
+            throw new Error("Can't write to computed field $id. Try writing to the id field directly.");
+          }
+          const currentSchema = getCurrentSchema(schema, value);
+          const nodePathArray = meta.nodePath?.split(".");
+          const notRoot = nodePathArray?.filter((x) => Number.isNaN(parseInt(x, 10))).join(".");
+          if (!currentSchema) {
+            throw new Error(`Schema not found for ${value.$entity || value.$relation}`);
+          }
+          value.$bzId = value.$tempId ?? `T_${uuidv4()}`;
+          value[Symbol.for("schema")] = currentSchema;
+          value[Symbol.for("dbId")] = currentSchema.defaultDBConnector.id;
+          const { usedLinkFields, usedRoleFields } = getCurrentFields(currentSchema, value);
+          const usedLinkFieldsMap = usedLinkFields.map(
+            (linkFieldPath) => ({
+              fieldType: "linkField",
+              path: linkFieldPath,
+              // @ts-expect-error - TODO description
+              schema: currentSchema.linkFields.find((y) => y.path === linkFieldPath)
+            })
+          );
+          const usedRoleFieldsMap = currentSchema.thingType === "relation" ? usedRoleFields.map(
+            (roleFieldPath) => ({
+              fieldType: "roleField",
+              path: roleFieldPath,
+              schema: oFind(currentSchema.roles, (k) => k === roleFieldPath)
+            })
+          ) : [];
+          if (usedLinkFieldsMap.some((x) => x.schema?.target === "role") && usedLinkFieldsMap.some((x) => x.schema?.target === "relation")) {
+            throw new Error(
+              "Unsupported: Can't use a link field with target === 'role' and another with target === 'relation' in the same mutation."
+            );
+          }
+          const multiplayedRoles = usedRoleFieldsMap.filter(
+            (roleField) => [...new Set(roleField.schema.playedBy?.map((x) => x.thing))].length !== 1
+          );
+          if (multiplayedRoles.length > 1) {
+            throw new Error(
+              `Field: ${multiplayedRoles[0].path} - If a role can be played by multiple things, you must specify the thing in the mutation: ${JSON.stringify(
+                multiplayedRoles[0].schema.playedBy
+              )}. Schema: ${JSON.stringify(multiplayedRoles[0].schema)}`
+            );
+          }
+          const currentPath = meta.nodePath;
+          [...usedLinkFieldsMap, ...usedRoleFieldsMap]?.forEach((currentField) => {
+            const currentValue = value[currentField.path];
+            if (currentValue === void 0) {
+              return;
+            }
+            const currentFieldSchema = currentField.schema;
+            if (!currentFieldSchema) {
+              throw new Error(`Field ${currentField.path} not found in schema`);
+            }
+            const currentEdgeSchema = (
+              // @ts-expect-error - TODO description
+              currentField.fieldType === "roleField" ? currentFieldSchema?.playedBy[0] : currentFieldSchema
+            );
+            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 = currentField.fieldType === "linkField" ? currentFieldSchema?.oppositeLinkFieldsPlayedBy : currentFieldSchema?.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 (currentFieldSchema.cardinality === "ONE") {
+              if (Array.isArray(currentValue)) {
+                throw new Error("Can't have an array in a cardinality === ONE link field");
+              }
+            }
+            if (currentFieldSchema.cardinality === "MANY" && currentValue !== null && !Array.isArray(currentValue) && !currentValue.$arrayOp) {
+              throw new Error(
+                `${// @ts-expect-error - TODO description
+                currentField.fieldType === "linkField" ? currentFieldSchema.path : currentFieldSchema.name} is a cardinality === MANY thing. Use an array or a $arrayOp object`
+              );
+            }
+            if (currentValue?.$entity || currentValue?.$relation) {
+              return;
+            }
+            const [childrenLinkField] = oppositeFields;
+            const currentFieldType = "plays" in currentFieldSchema ? "linkField" : "roleField";
+            const childrenThingObj = {
+              [`$${childrenLinkField.thingType}`]: childrenLinkField.thing,
+              [Symbol.for("relation")]: relation,
+              [Symbol.for("edgeType")]: currentFieldType,
+              [Symbol.for("parent")]: {
+                path: currentPath,
+                ...value.$id ? { $id: value.$id } : {},
+                ...value.$tempId ? { $tempId: value.$tempId } : {},
+                ...value.filter ? { filter: value.filter } : {},
+                links: oppositeFields
+              },
+              [Symbol.for("role")]: childrenLinkField.plays,
+              // this is the currentChildren
+              // this is the parent
+              [Symbol.for("oppositeRole")]: "plays" in currentFieldSchema ? currentFieldSchema.plays : void 0,
+              // todo
+              [Symbol.for("relFieldSchema")]: currentFieldSchema
+            };
+            if (isObject3(currentValue)) {
+              value[currentField.path] = {
+                ...childrenThingObj,
+                ...currentValue
+              };
+            }
+            if (Array.isArray(currentValue)) {
+              if (currentValue.every((x) => isObject3(x))) {
+                value[currentField.path] = currentValue.map((y) => {
+                  return {
+                    ...childrenThingObj,
+                    ...y
+                  };
+                });
+              } else if (currentValue.every((x) => typeof x === "string")) {
+                value[currentField.path] = currentValue.map((y) => ({
+                  ...childrenThingObj,
+                  $op: value.$op === "create" ? "link" : "replace",
+                  $id: y
+                }));
+              } else {
+                throw new Error(`Invalid array value for ${currentField.path}`);
+              }
+            }
+            if (typeof currentValue === "string") {
+              value[currentField.path] = {
+                ...childrenThingObj,
+                $op: value.$op === "create" ? "link" : "replace",
+                // if the parent is being created, then is not a replace, is a new link
+                $id: currentValue
+                // todo: now all strings are ids and not tempIds, but in the future this might change
+              };
+            }
+            if (currentValue === null) {
+              const neutralObject = {
+                ...childrenThingObj,
+                $op: "unlink"
+                // todo: embedded => delete
+              };
+              value[currentField.path] = currentFieldSchema.cardinality === "MANY" ? [neutralObject] : neutralObject;
+            }
+          });
+          if (!notRoot && !value.$entity && !value.$relation) {
+            throw new Error("Root things must specify $entity or $relation");
+          }
+          if (!notRoot) {
+          }
+        }
+      })
+    );
+  };
+  const withObjects = stringToObjects(shakedBqlRequest);
+  const fill = (blocks) => {
+    return produce3(
+      blocks,
+      (draft) => traverse3(draft, ({ parent, key, value: val, meta }) => {
+        if (isObject3(val)) {
+          if (Object.keys(val).length === 0) {
+            throw new Error("Empty object!");
+          }
+          if (key === "$filter" || meta.nodePath?.includes(".$filter.")) {
+            return;
+          }
+          const value = val;
+          const nodePathArray = meta.nodePath?.split(".");
+          if (value.$tempId) {
+            if (!(value.$op === void 0 || value.$op === "link" || value.$op === "create" || value.$op === "update")) {
+              throw new Error(
+                `Invalid op ${value.$op} for tempId. TempIds can be created, or when created in another part of the same mutation. In the future maybe we can use them to catch stuff in the DB as well and group them under the same tempId.`
+              );
+            }
+          }
+          const notRoot = nodePathArray?.filter((x) => Number.isNaN(parseInt(x, 10))).join(".");
+          const currentPath = !notRoot ? meta.nodePath || "" : Array.isArray(parent) ? nodePathArray?.slice(0, -1).join(".") : meta.nodePath;
+          const currentSchema = getCurrentSchema(schema, value);
+          const { unidentifiedFields, dataFields, roleFields, linkFields } = getCurrentFields(currentSchema, value);
+          const parentMeta = current(value)[Symbol.for("parent")];
+          const parentPath = notRoot && parentMeta.path;
+          const parentNode = !parentPath ? draft : getNodeByPath(draft, parentPath);
+          const parentOp = parentNode?.$op;
+          if (notRoot && !parentOp) {
+            throw new Error("Error: Parent $op not detected");
+          }
+          const currentFieldSchema = value[Symbol.for("relFieldSchema")];
+          if (value.$op === "replace") {
+            if (parentOp === "create") {
+              value.$op = "link";
+            }
+          }
+          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 (notRoot && !value.$id && !value.$tempId && parentOp !== "create" && currentFieldSchema.cardinality === "ONE") {
+              throw new Error(`Please specify if it is a create or an update. Path: ${meta.nodePath}`);
+            }
+            if (value.$tempId) {
+              return "create";
+            }
+            if ((value.$id || value.$filter) && hasUpdatedDataFields) {
+              return "update";
+            }
+            if ((value.$id || value.$filter) && notRoot && !hasUpdatedDataFields && !hasUpdatedChildren) {
+              return "link";
+            }
+            if (!value.$filter && !value.$id && !value.$tempId) {
+              return "create";
+            }
+            if ((value.$id || value.$filter) && !hasUpdatedDataFields && hasUpdatedChildren) {
+              return "match";
+            }
+            throw new Error("Wrong op");
+          };
+          if (!value.$op) {
+            value.$op = getOp();
+          }
+          if (!parent) {
+            value.$parentKey = "";
+          }
+          if (typeof parent === "object") {
+            const ArParent = Array.isArray(parent);
+            if (ArParent) {
+              value[Symbol.for("index")] = key;
+            }
+            value[Symbol.for("path")] = currentPath;
+            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, virtualFields } = currentSchema;
+          if (!idFields) {
+            throw new Error("No idFields found");
+          }
+          const [idField] = idFields;
+          const filledFields = listify4(value, (attKey, v) => v !== void 0 ? attKey : void 0);
+          const virtualFilledFields = filledFields.filter((x) => virtualFields?.includes(x));
+          if (virtualFilledFields.length > 0) {
+            throw new Error(`Virtual fields can't be sent to DB: "${virtualFilledFields.join(",")}"`);
+          }
+          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 = compute({
+                currentThing: value,
+                fieldSchema: currentDef,
+                //id is always a datafield.
+                mandatoryDependencies: true
+                //can't send to db without every dependency being there
+              });
+              value[fieldPath] = defaultValue;
+              value.$id = defaultValue;
+            }
+          });
+          if (unidentifiedFields.length > 0) {
+            throw new Error(`Unknown fields: [${unidentifiedFields.join(",")}] in ${JSON.stringify(value)}`);
+          }
+        }
+      })
+    );
+  };
+  const filledBQLMutation = fill(withObjects);
+  if (Array.isArray(filledBQLMutation)) {
+    req.filledBqlRequest = filledBQLMutation;
+  } else {
+    req.filledBqlRequest = filledBQLMutation;
+  }
+};
+
+// src/pipeline/preprocess/parseBQLMutation.ts
+import { getNodeByPath as getNodeByPath2, traverse as traverse4 } from "object-traversal";
+import { isArray as isArray2, isObject as isObject4, mapEntries as mapEntries3, pick, shake as shake3 } from "radash";
+import { v4 as uuidv42 } from "uuid";
+var parseBQLMutation = async (req) => {
+  const { filledBqlRequest, schema } = req;
+  const listNodes = (blocks) => {
+    const nodes = [];
+    const edges = [];
+    const getIdValue = (node) => {
+      if (node.$id) {
+        return node.$id;
+      }
+      const currentSchema = getCurrentSchema(schema, node);
+      const { idFields } = currentSchema;
+      if (!idFields) {
+        throw new Error(`no idFields: ${JSON.stringify(node)}`);
+      }
+      const [idField] = idFields;
+      if (!idField) {
+        throw new Error(`no idField: ${JSON.stringify(node)}`);
+      }
+      const idDataField = currentSchema.dataFields?.find((x) => x.path === idField);
+      const idDefaultValue = node.$op === "create" ? idDataField?.default?.value() : null;
+      const idValue = node[idField] || node.$id || idDefaultValue;
+      if (!idValue) {
+        throw new Error(`no idValue: ${JSON.stringify(node)}`);
+      }
+      return idValue;
+    };
+    const toNodes = (node) => {
+      if (node.$op === "create") {
+        const idValue = getIdValue(node);
+        if (nodes.find((x) => x.$id === idValue)) {
+          throw new Error(`Duplicate id ${idValue} for node ${JSON.stringify(node)}`);
+        }
+        if (edges.find((x) => x.$bzId === node.$bzId)) {
+          throw new Error(`Duplicate $bzid ${node.$bzId} for node ${JSON.stringify(node)}`);
+        }
+        nodes.push({ ...node, $id: idValue });
+        return;
+      }
+      if (node.$tempId && node.$op === "match") {
+        return;
+      }
+      nodes.push(node);
+    };
+    const toEdges = (edge) => {
+      if (edge.$op === "create") {
+        const idValue = getIdValue(edge);
+        if (nodes.find((x) => x.$id === idValue)) {
+        }
+        if (edges.find((x) => x.$bzId === edge.$bzId)) {
+          throw new Error(`Duplicate %bzId ${edge.$bzIdd} for edge ${JSON.stringify(edge)}`);
+        }
+        edges.push({ ...edge, $id: idValue });
+        return;
+      }
+      edges.push(edge);
+    };
+    const listOp = ({ value: val }) => {
+      if (!isObject4(val)) {
+        return;
+      }
+      const value = val;
+      if (value.$entity || value.$relation) {
+        if (!value.$op) {
+          throw new Error(`Operation should be defined at this step ${JSON.stringify(value)}`);
+        }
+        if (!value.$bzId) {
+          throw new Error("[internal error] BzId not found");
+        }
+        const currentThingSchema = getCurrentSchema(schema, value);
+        const {
+          dataFields: dataFieldPaths,
+          roleFields: roleFieldPaths,
+          linkFields: linkFieldPaths,
+          usedFields
+        } = getCurrentFields(currentThingSchema, value);
+        const getChildOp = () => {
+          if (value.$op === "create" || value.$op === "delete") {
+            return value.$op;
+          }
+          if (value.$op === "update") {
+            const usedDataFields = usedFields.filter((x) => dataFieldPaths?.includes(x));
+            const usedRoleFields = usedFields.filter((x) => roleFieldPaths?.includes(x));
+            const usedLinkFields = usedFields.filter((x) => linkFieldPaths?.includes(x));
+            if (usedDataFields.length > 0) {
+              return "update";
+            }
+            if (usedRoleFields.length > 0 || usedLinkFields.length > 0) {
+              return "match";
+            }
+            throw new Error(`No fields on an $op:"update" for node ${JSON.stringify(value)}`);
+          }
+          return "match";
+        };
+        const dataObj = {
+          ...value.$entity && { $entity: value.$entity },
+          ...value.$relation && { $relation: value.$relation },
+          ...value.$id && { $id: value.$id },
+          ...value.$tempId && { $tempId: value.$tempId },
+          ...value.$filter && { $filter: value.$filter },
+          ...shake3(pick(value, dataFieldPaths || [""])),
+          $op: getChildOp(),
+          $bzId: value.$bzId,
+          [Symbol.for("dbId")]: currentThingSchema.defaultDBConnector.id,
+          // [Symbol.for('dependencies')]: value[Symbol.for('dependencies')],
+          [Symbol.for("path")]: value[Symbol.for("path")],
+          [Symbol.for("parent")]: value[Symbol.for("parent")],
+          [Symbol.for("isRoot")]: value[Symbol.for("isRoot")],
+          [Symbol.for("isLocalId")]: value[Symbol.for("isLocalId")] || false
+        };
+        toNodes(dataObj);
+        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: "match" });
+            }
+          }
+          const ownRelation = value[Symbol.for("relation")] === value.$relation;
+          const linkTempId = ownRelation ? value.$bzId : uuidv42();
+          const parentMeta = value[Symbol.for("parent")];
+          const parentPath = parentMeta.path;
+          const parentNode = !parentPath ? blocks : getNodeByPath2(blocks, parentPath);
+          const parentId = parentNode.$bzId;
+          if (!parentId) {
+            throw new Error("No parent id found");
+          }
+          if (value[Symbol.for("relation")] === "$self") {
+            return;
+          }
+          const getLinkObjOp = () => {
+            if (value.$op === "delete") {
+              if (ownRelation) {
+                return "match";
+              }
+              return "delete";
+            }
+            if (value.$op === "unlink") {
+              if (ownRelation) {
+                return "unlink";
+              }
+              return "delete";
+            }
+            if (value.$op === "link" || value.$op === "create") {
+              if (ownRelation) {
+                return "link";
+              }
+              return "create";
+            }
+            if (value.$op === "replace") {
+              throw new Error("Unsupported: Nested replaces not implemented yet");
+            }
+            return "match";
+          };
+          const edgeType1 = {
+            $relation: value[Symbol.for("relation")],
+            $bzId: linkTempId,
+            ...value.$tempId ? { $tempId: value.$tempId } : {},
+            $op: getLinkObjOp(),
+            // roles
+            ...!ownRelation ? { [value[Symbol.for("role")]]: value.$bzId } : {},
+            [value[Symbol.for("oppositeRole")]]: parentId,
+            [Symbol.for("dbId")]: schema.relations[value[Symbol.for("relation")]].defaultDBConnector.id,
+            [Symbol.for("edgeType")]: "linkField",
+            [Symbol.for("info")]: "normal linkField",
+            [Symbol.for("path")]: value[Symbol.for("path")],
+            [Symbol.for("parent")]: value[Symbol.for("parent")]
+          };
+          toEdges(edgeType1);
+          if ((value.$op === "unlink" || getLinkObjOp() === "unlink") && ownRelation) {
+            toEdges({
+              $relation: value[Symbol.for("relation")],
+              $bzId: linkTempId,
+              $op: "match",
+              [value[Symbol.for("oppositeRole")]]: parentId,
+              [Symbol.for("dbId")]: schema.relations[value[Symbol.for("relation")]].defaultDBConnector.id,
+              [Symbol.for("edgeType")]: "linkField",
+              [Symbol.for("info")]: "additional ownrelation unlink linkField",
+              [Symbol.for("path")]: value[Symbol.for("path")],
+              [Symbol.for("parent")]: value[Symbol.for("parent")]
+            });
+          }
+        }
+        if (value.$relation) {
+          const rolesObjFiltered = oFilter(value, (k, _v) => roleFieldPaths.includes(k));
+          const rolesObjOnlyIds = mapEntries3(rolesObjFiltered, (k, v) => {
+            if (isArray2(v)) {
+              return [k, v];
+            }
+            if (isObject4(v)) {
+              return [k, v.$bzId];
+            }
+            return [k, v];
+          });
+          const objWithMetaDataOnly = oFilter(val, (k, _v) => {
+            return k.startsWith("$") || k.startsWith("Symbol");
+          });
+          if (Object.keys(rolesObjFiltered).filter((x) => !x.startsWith("$")).length > 0) {
+            if (value.$op === "create" || value.$op === "delete") {
+              const getEdgeOp = () => {
+                if (value.$op === "create") {
+                  return "link";
+                }
+                if (value.$op === "delete") {
+                  return "match";
+                }
+                throw new Error("Unsupported parent of edge op");
+              };
+              const rolesObjOnlyIdsGrouped = mapEntries3(rolesObjOnlyIds, (k, v) => {
+                if (Array.isArray(v)) {
+                  return [k, v.map((vNested) => vNested.$bzId || vNested)];
+                }
+                return [k, v.$bzId || v];
+              });
+              const edgeType2 = {
+                ...objWithMetaDataOnly,
+                $relation: value.$relation,
+                $op: getEdgeOp(),
+                ...rolesObjOnlyIdsGrouped,
+                // override role fields by ids or tempIDs
+                $bzId: value.$bzId,
+                [Symbol.for("path")]: value[Symbol.for("path")],
+                [Symbol.for("dbId")]: currentThingSchema.defaultDBConnector.id,
+                [Symbol.for("info")]: "coming from created or deleted relation",
+                [Symbol.for("edgeType")]: "roleField on C/D"
+              };
+              toEdges(edgeType2);
+              return;
+            }
+            if (value.$op === "match" || value.$op === "update" && Object.keys(rolesObjFiltered).length > 0) {
+              let totalUnlinks = 0;
+              Object.entries(rolesObjFiltered).forEach(([role, operations]) => {
+                const operationsArray = isArray2(operations) ? operations : [operations];
+                const getOp = (childOp) => {
+                  if (childOp === "create" || childOp === "replace") {
+                    return "link";
+                  }
+                  return childOp;
+                };
+                operationsArray.forEach((operation) => {
+                  if (!operation) {
+                    return;
+                  }
+                  const op = getOp(operation.$op);
+                  if (op === "replace") {
+                    throw new Error("Not supported yet: replace on roleFields");
+                  }
+                  if (op === "unlink" && totalUnlinks > 0) {
+                    totalUnlinks += 1;
+                    throw new Error(
+                      "Not supported yet: Cannot unlink more than one role at a time, please split into two mutations"
+                    );
+                  }
+                  const edgeType3 = {
+                    ...objWithMetaDataOnly,
+                    $relation: value.$relation,
+                    $op: op === "delete" ? "unlink" : op,
+                    [role]: operation.$bzId,
+                    $bzId: value.$bzId,
+                    [Symbol.for("dbId")]: currentThingSchema.defaultDBConnector.id,
+                    [Symbol.for("parent")]: value[Symbol.for("parent")],
+                    [Symbol.for("path")]: value[Symbol.for("path")],
+                    [Symbol.for("info")]: "updating roleFields",
+                    [Symbol.for("edgeType")]: "roleField on L/U/R"
+                  };
+                  toEdges(edgeType3);
+                  if (op === "unlink") {
+                  }
+                });
+              });
+            }
+          }
+        }
+      }
+    };
+    traverse4(blocks, listOp);
+    return [nodes, edges];
+  };
+  if (!filledBqlRequest) {
+    throw new Error("Undefined filledBqlRequest");
+  }
+  const [parsedThings, parsedEdges] = listNodes(filledBqlRequest);
+  const mergedThings = parsedThings.reduce((acc, thing) => {
+    if (!thing.$bzId) {
+      return [...acc, thing];
+    }
+    const existingIndex = acc.findIndex((t) => t.$bzId === thing.$bzId);
+    if (existingIndex === -1) {
+      return [...acc, thing];
+    }
+    if (acc[existingIndex].$op === "create" && thing.$op === "match") {
+      return acc;
+    }
+    if (acc[existingIndex].$op === "match" && (thing.$op === "create" || thing.$op === "match")) {
+      return [...acc.slice(0, existingIndex), thing, ...acc.slice(existingIndex + 1)];
+    }
+    throw new Error(
+      `Unsupported operation combination for $tempId "${thing.$tempId}". Existing: ${acc[existingIndex].$op}. Current: ${thing.$op}`
+    );
+  }, []);
+  const mergedEdges = parsedEdges.reduce((acc, curr) => {
+    const existingEdge = acc.find(
+      (r) => (r.$id && r.$id === curr.$id || r.$bzId && r.$bzId === curr.$bzId) && r.$relation === curr.$relation && r.$op === curr.$op
+    );
+    if (existingEdge) {
+      const newRelation = { ...existingEdge };
+      Object.keys(curr).forEach((key) => {
+        if (typeof key === "symbol" || key.startsWith("$")) {
+          return;
+        }
+        const existingVal = existingEdge[key];
+        const currVal = curr[key];
+        if (Array.isArray(existingVal) && Array.isArray(currVal)) {
+          newRelation[key] = Array.from(/* @__PURE__ */ new Set([...existingVal, ...currVal]));
+        } else if (!Array.isArray(existingVal) && Array.isArray(currVal)) {
+          if (existingVal !== void 0) {
+            newRelation[key] = Array.from(/* @__PURE__ */ new Set([existingVal, ...currVal]));
+          } else {
+            newRelation[key] = currVal;
+          }
+        } else if (Array.isArray(existingVal) && !Array.isArray(currVal)) {
+          if (currVal !== void 0) {
+            newRelation[key] = Array.from(/* @__PURE__ */ new Set([...existingVal, currVal]));
+          }
+        } else if (!existingVal) {
+          newRelation[key] = currVal;
+        }
+      });
+      const newAcc = acc.filter(
+        (r) => !((r.$id && r.$id === curr.$id || r.$bzId && r.$bzId === curr.$bzId) && r.$relation === curr.$relation && r.$op === curr.$op)
+      );
+      return [...newAcc, newRelation];
+    }
+    return [...acc, curr];
+  }, []);
+  const uniqueRelations = [...new Set(mergedEdges.map((x) => x.$relation))];
+  const _checkCardinality = () => {
+    const problematicEdges = {};
+    uniqueRelations.forEach((relation) => {
+      const cardinalityOneRoles = Object.keys(schema.relations[relation].roles).filter(
+        (role) => schema.relations[relation].roles[role].cardinality === "ONE"
+      );
+      cardinalityOneRoles.forEach((oneRole) => {
+        const idMapping = {};
+        mergedEdges.forEach((edge) => {
+          if (edge.$relation === relation && edge[oneRole]) {
+            const oneId = edge[oneRole];
+            const otherRole = Object.keys(edge).find(
+              (role) => role !== "$relation" && role !== "$op" && role !== "$id" && role !== oneRole
+            );
+            if (otherRole) {
+              const otherId = edge[otherRole];
+              if (!idMapping[otherId]) {
+                idMapping[otherId] = /* @__PURE__ */ new Set();
+              }
+              idMapping[otherId].add(oneId);
+            }
+          }
+        });
+        Object.entries(idMapping).forEach(([otherId, oneIds]) => {
+          if (oneIds.size > 1) {
+            throw new Error(
+              `${relation} has illegal cardinality: The ${oneRole} role is linked to multiple ${Object.keys(
+                idMapping[otherId]
+              ).join(",")} roles.`
+            );
+          }
+        });
+      });
+    });
+    if (Object.keys(problematicEdges).length > 0) {
+      let errorMessage = "";
+      Object.entries(problematicEdges).forEach(([otherId, errorSet]) => {
+        errorMessage += `"${otherId}" is connected to many entities. ${Array.from(errorSet).join(" ")}The relation's role is of cardinality ONE.
+`;
+      });
+      throw new Error(errorMessage);
+    }
+  };
+  req.bqlRequest = {
+    mutation: {
+      things: mergedThings,
+      edges: mergedEdges
+    }
+  };
+};
+
+// src/pipeline/transaction/runTQLMutation.ts
+import { TransactionType as TransactionType2 } from "typedb-driver";
+
+// src/pipeline/transaction/helpers.ts
+import { SessionType as SessionType2 } from "typedb-driver";
+var getSessionOrOpenNewOne = async (dbHandles, config) => {
+  const singleHandlerV0 = config.dbConnectors[0].id;
+  let session = dbHandles.typeDB.get(singleHandlerV0)?.session;
+  const client = dbHandles.typeDB.get(singleHandlerV0)?.client;
+  if (!session || !session.isOpen()) {
+    if (!client) {
+      throw new Error("Client not found");
+    }
+    session = await client.session(config.dbConnectors[0].dbName, SessionType2.DATA);
+    dbHandles.typeDB.set(singleHandlerV0, { client, session });
+  }
+  return { client, session };
+};
+
+// src/pipeline/transaction/runTQLMutation.ts
+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 { session } = await getSessionOrOpenNewOne(dbHandles, config);
+  const mutateTransaction = await session.transaction(TransactionType2.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) {
+    await mutateTransaction.query.delete(tqlDeletion);
+  }
+  const insertionsStream = tqlInsertion && mutateTransaction.query.insert(tqlInsertion);
+  try {
+    const insertionsRes = insertionsStream ? await insertionsStream.collect() : void 0;
+    await mutateTransaction.commit();
+    await mutateTransaction.close();
+    res.rawTqlRes = { insertions: insertionsRes };
+  } catch (e) {
+    await mutateTransaction.close();
+    throw new Error(`Transaction failed: ${e.message}`);
+  }
+};
+
+// src/pipeline/preprocess/buildTQLQuery.ts
+var separator = "___";
+var newBuildTQLQuery = async (req) => {
+  const { enrichedBqlQuery } = req;
+  if (!enrichedBqlQuery) {
+    throw new Error("BQL query not enriched");
+  }
+  let tqlStr = "";
+  const processFilters = ($filter, $var) => {
+    let simpleHas = "";
+    let orHas = "";
+    for (const key in $filter) {
+      const filterKey = $filter[key];
+      if (Array.isArray(filterKey)) {
+        for (let i = 0; i < filterKey.length; i++) {
+          orHas += `{$${$var} has ${key} "${filterKey[i]}";}`;
+          if (i < filterKey.length - 1) {
+            orHas += "or";
+          } else {
+            orHas += ";";
+          }
+        }
+      } else {
+        simpleHas += `, has ${key} "${filterKey}"`;
+      }
+    }
+    simpleHas += "; \n";
+    tqlStr += simpleHas;
+    tqlStr += orHas;
+  };
+  const processDataFields = (dataFields, $path) => {
+    const postStrParts = [];
+    const asMetaDataParts = [];
+    const virtualMetaDataParts = [];
+    let $asMetaData = "";
+    let $virtualMetaData = "";
+    for (let i = 0; i < dataFields.length; i++) {
+      if (!dataFields[i].$isVirtual) {
+        postStrParts.push(` ${dataFields[i].$dbPath}`);
+      } else {
+        virtualMetaDataParts.push(`${dataFields[i].$dbPath}`);
+      }
+      asMetaDataParts.push(`{${dataFields[i].$dbPath}:${dataFields[i].$as}}`);
+    }
+    const postStr = `${postStrParts.join(",")};
+`;
+    $asMetaData = asMetaDataParts.join(",");
+    $virtualMetaData = virtualMetaDataParts.join(",");
+    const $metaData = `$metadata:{as:[${$asMetaData}],virtual:[${$virtualMetaData}]}`;
+    tqlStr += `$${$path} as "${$path}.${$metaData}.$dataFields": `;
+    tqlStr += postStr;
+  };
+  const processRoleFields = (roleFields, $path, dotPath) => {
+    for (const roleField of roleFields) {
+      const { $fields, $as, $justId, $idNotIncluded, $filterByUnique } = roleField;
+      const $metaData = `$metadata:{as:${$as},justId:${$justId ? "T" : "F"},idNotIncluded:${$idNotIncluded},filterByUnique:${$filterByUnique}}`;
+      tqlStr += `"${dotPath}.${$metaData}.${roleField.$var}":{ 
+`;
+      tqlStr += "	match \n";
+      if (roleField.$filter) {
+        tqlStr += ` $${$path}${separator}${roleField.$var} isa ${roleField.$thing}`;
+        processFilters(roleField.$filter, `${$path}${separator}${roleField.$var}`);
+      }
+      tqlStr += `	$${$path} (${roleField.$var}: $${$path}${separator}${roleField.$var}) isa ${roleField.$intermediary}; 
+`;
+      if ($fields) {
+        tqlStr += "	fetch \n";
+      }
+      const dataFields = $fields?.filter((f) => f.$fieldType === "data");
+      if (dataFields && dataFields.length > 0) {
+        processDataFields(dataFields, `${$path}${separator}${roleField.$var}`, `${$path}.${roleField.$var}`);
+      }
+      const linkFields = $fields?.filter((f) => f.$fieldType === "link");
+      if (linkFields && linkFields.length > 0) {
+        processLinkFields(linkFields, `${$path}${separator}${roleField.$var}`, `${$path}.${roleField.$var}`);
+      }
+      const roleFields2 = $fields?.filter((f) => f.$fieldType === "role");
+      if (roleFields2 && roleFields2.length > 0) {
+        processRoleFields(roleFields2, `${$path}${separator}${roleField.$var}`, `${$path}.${roleField.$var}`);
+      }
+      tqlStr += "}; \n";
+    }
+  };
+  const processLinkFields = (linkFields, $path, dotPath) => {
+    for (const linkField of linkFields) {
+      const { $fields, $as, $justId, $idNotIncluded, $filterByUnique, $playedBy } = linkField;
+      const $metaData = `$metadata:{as:${$as},justId:${$justId ? "T" : "F"},idNotIncluded:${$idNotIncluded},filterByUnique:${$filterByUnique}}`;
+      tqlStr += `"${dotPath}.${$metaData}.${linkField.$var}":{ 
+`;
+      tqlStr += "	match \n";
+      if (linkField.$filter) {
+        tqlStr += ` $${$path}${separator}${linkField.$var} isa ${linkField.$thing}`;
+        processFilters(linkField.$filter, `${$path}${separator}${linkField.$var}`);
+      }
+      if (linkField.$target === "role") {
+        tqlStr += `	$${$path}_intermediary (${linkField.$plays}: $${$path}, ${$playedBy.plays}: $${$path}${separator}${linkField.$var}) isa ${linkField.$intermediary}; 
+`;
+      } else {
+        tqlStr += `	$${$path}${separator}${linkField.$var} (${linkField.$plays}: $${$path}) isa ${linkField.$thing}; 
+`;
+      }
+      if ($fields) {
+        tqlStr += "	fetch \n";
+      }
+      const dataFields = $fields?.filter((f) => f.$fieldType === "data");
+      if (dataFields && dataFields.length > 0) {
+        processDataFields(dataFields, `${$path}${separator}${linkField.$var}`);
+      }
+      const linkFields2 = $fields?.filter((f) => f.$fieldType === "link");
+      if (linkFields2 && linkFields2.length > 0) {
+        processLinkFields(linkFields2, `${$path}${separator}${linkField.$var}`, `${$path}.${linkField.$var}`);
+      }
+      const roleFields = $fields?.filter((f) => f.$fieldType === "role");
+      if (roleFields && roleFields.length > 0) {
+        processRoleFields(roleFields, `${$path}${separator}${linkField.$var}`, `${$path}.${linkField.$var}`);
+      }
+      tqlStr += "}; \n";
+    }
+  };
+  const isBatched = enrichedBqlQuery.length > 1;
+  const tqlStrings = [];
+  const builder = (enrichedBqlQuery2) => {
+    if (isBatched) {
+      for (const query of enrichedBqlQuery2) {
+        const { $path, $thing, $filter, $fields } = query;
+        tqlStr += `match 
+ 	 $${$path} isa ${$thing} `;
+        if ($filter) {
+          processFilters($filter, $path);
+        } else {
+          tqlStr += "; ";
+        }
+        if ($fields) {
+          tqlStr += "fetch \n";
+        }
+        const dataFields = $fields?.filter((f) => f.$fieldType === "data");
+        if (dataFields && dataFields.length > 0) {
+          processDataFields(dataFields, $path);
+        }
+        const linkFields = $fields?.filter((f) => f.$fieldType === "link");
+        if (linkFields && linkFields.length > 0) {
+          processLinkFields(linkFields, $path, $path);
+        }
+        const roleFields = $fields?.filter((f) => f.$fieldType === "role");
+        if (roleFields && roleFields.length > 0) {
+          processRoleFields(roleFields, $path, $path);
+        }
+        tqlStrings.push(tqlStr);
+        tqlStr = "";
+      }
+    } else {
+      for (const query of enrichedBqlQuery2) {
+        const { $path, $thing, $filter, $fields } = query;
+        tqlStr += `match 
+ 	 $${$path} isa ${$thing} `;
+        if ($filter) {
+          processFilters($filter, $path);
+        } else {
+          tqlStr += "; ";
+        }
+        if ($fields) {
+          tqlStr += "fetch \n";
+        }
+        const dataFields = $fields?.filter((f) => f.$fieldType === "data");
+        if (dataFields && dataFields.length > 0) {
+          processDataFields(dataFields, $path);
+        }
+        const linkFields = $fields?.filter((f) => f.$fieldType === "link");
+        if (linkFields && linkFields.length > 0) {
+          processLinkFields(linkFields, $path, $path);
+        }
+        const roleFields = $fields?.filter((f) => f.$fieldType === "role");
+        if (roleFields && roleFields.length > 0) {
+          processRoleFields(roleFields, $path, $path);
+        }
+      }
+    }
+  };
+  builder(enrichedBqlQuery);
+  req.tqlRequest = isBatched ? tqlStrings : tqlStr;
+};
+
+// src/pipeline/preprocess/enrichBQLQuery.ts
+import { produce as produce4 } from "immer";
+import { traverse as traverse5 } from "object-traversal";
+import { isObject as isObject5 } from "radash";
+var getAllFields = (currentSchema) => {
+  const dataFields = currentSchema.dataFields?.map((field) => field.path) || [];
+  const linkFields = currentSchema.linkFields?.map((field) => field.path) || [];
+  const roleFields = Object.keys(currentSchema.roles || {}) || [];
+  const allFields = [...dataFields, ...linkFields, ...roleFields];
+  return allFields;
+};
+var checkFilterByUnique = ($filter, currentSchema) => {
+  const fields = Object.keys($filter || {});
+  return fields.some((field) => {
+    if (!Array.isArray($filter[field])) {
+      const isIdField = currentSchema.idFields?.includes(field);
+      const isUniqueDataField = currentSchema.dataFields?.some(
+        (f) => (f.dbPath === field || f.path === field) && f?.validations?.unique
+      );
+      return isIdField || isUniqueDataField;
+    }
+    return false;
+  });
+};
+var processFilter = ($filter, currentSchema) => {
+  const dataFields = currentSchema.dataFields?.map((field) => ({ path: field.path, dbPath: field.dbPath })) || [];
+  const linkFields = currentSchema.linkFields?.map((field) => ({ path: field.path, dbPath: field.dbPath })) || [];
+  const roleFields = Object.keys(currentSchema.roles || {}).map((field) => ({ path: field, dbPath: field })) || [];
+  const allFields = [...dataFields, ...linkFields, ...roleFields];
+  return Object.entries($filter || {}).reduce((newFilter, [filterKey, filterValue]) => {
+    const field = allFields.find((o) => o.path === filterKey);
+    newFilter[field?.dbPath || filterKey] = filterValue;
+    return newFilter;
+  }, {});
+};
+var enrichBQLQuery = async (req) => {
+  const { rawBqlRequest: rawBqlQuery, schema } = req;
+  if (!Array.isArray(rawBqlQuery)) {
+    if (!("$entity" in rawBqlQuery) && !("$relation" in rawBqlQuery) && (!("$thing" in rawBqlQuery) || !("$thingType" in rawBqlQuery))) {
+      throw new Error("No entity specified in query");
+    }
+  } else {
+    for (const item of rawBqlQuery) {
+      if (!("$entity" in item) && !("$relation" in item) && (!("$thing" in item) || !("$thingType" in item))) {
+        throw new Error("No entity specified in query");
+      }
+    }
+  }
+  const createDataField = (field, fieldStr, $justId, dbPath, isVirtual) => {
+    return {
+      $path: fieldStr,
+      $dbPath: dbPath,
+      $thingType: "attribute",
+      $as: field.$as || fieldStr,
+      $var: fieldStr,
+      $fieldType: "data",
+      $justId,
+      $id: field.$id,
+      $filter: field.$filter,
+      $isVirtual: isVirtual,
+      // ...(typeof field !== 'string' && { $fields: [...field.$fields, ...['id']] }),
+      $filterProcessed: true
+    };
+  };
+  const createLinkField = (field, fieldStr, linkField, $justId, dbPath) => {
+    const { target, oppositeLinkFieldsPlayedBy } = linkField;
+    return oppositeLinkFieldsPlayedBy.map((playedBy) => {
+      const $thingType = target === "role" ? playedBy.thingType : "relation";
+      const $thing = target === "role" ? playedBy.thing : linkField.relation;
+      const node = { [`$${$thingType}`]: $thing };
+      const currentSchema = getCurrentSchema(schema, node);
+      const idNotIncluded = field?.$fields?.filter(
+        (field2) => currentSchema?.idFields?.includes(field2) || currentSchema?.idFields?.includes(field2.$path)
+      ).length === 0;
+      let fields = [];
+      if (typeof field !== "string") {
+        if (field.$fields) {
+          if (idNotIncluded) {
+            fields = [...field.$fields, ...currentSchema.idFields];
+          } else {
+            fields = field.$fields;
+          }
+        } else {
+          fields = getAllFields(currentSchema);
+        }
+      } else {
+        fields = ["id"];
+      }
+      if (field.$excludedFields) {
+        fields = fields.filter((f) => !field.$excludedFields.includes(f.$path));
+      }
+      return {
+        $thingType,
+        $plays: linkField.plays,
+        $playedBy: playedBy,
+        $path: playedBy.path,
+        $dbPath: dbPath,
+        $as: field.$as || fieldStr,
+        $var: fieldStr,
+        $thing,
+        $fields: fields,
+        $fieldType: "link",
+        $target: target,
+        $intermediary: playedBy.relation,
+        $justId,
+        $id: field.$id,
+        $filter: processFilter(field.$filter, currentSchema),
+        $idNotIncluded: idNotIncluded,
+        $filterByUnique: checkFilterByUnique(field.$filter, currentSchema),
+        $filterProcessed: true
+      };
+    });
+  };
+  const createRoleField = (field, fieldStr, roleField, $justId, dbPath) => {
+    return roleField.playedBy.map((playedBy) => {
+      const { thing, thingType, relation } = playedBy;
+      const node = { [`$${thingType}`]: thing };
+      const currentSchema = getCurrentSchema(schema, node);
+      const idNotIncluded = field?.$fields?.filter(
+        (field2) => currentSchema?.idFields?.includes(field2) || currentSchema?.idFields?.includes(field2.$path)
+      ).length === 0;
+      let fields = [];
+      if (typeof field !== "string") {
+        if (field.$fields) {
+          if (idNotIncluded) {
+            fields = [...field.$fields, ...currentSchema.idFields];
+          } else {
+            fields = field.$fields;
+          }
+        } else {
+          fields = getAllFields(currentSchema);
+        }
+      } else {
+        fields = ["id"];
+      }
+      if (field.$excludedFields) {
+        fields = fields.filter((f) => !field.$excludedFields.includes(f.$path));
+      }
+      return {
+        $thingType: thingType,
+        $path: fieldStr,
+        $dbPath: dbPath,
+        $as: field.$as || fieldStr,
+        $var: fieldStr,
+        $thing: thing,
+        $fields: fields,
+        $fieldType: "role",
+        $intermediary: relation,
+        $justId,
+        $id: field.$id,
+        $filter: processFilter(field.$filter, currentSchema),
+        $idNotIncluded: idNotIncluded,
+        $filterByUnique: checkFilterByUnique(field.$filter, currentSchema),
+        $playedBy: playedBy,
+        $filterProcessed: true
+      };
+    });
+  };
+  const processField = (field, schema2) => {
+    const fieldStr = typeof field === "string" ? field : field.$path;
+    const justId = typeof field === "string";
+    const isDataField = schema2.dataFields?.find((dataField) => dataField.path === fieldStr);
+    const isLinkField = schema2.linkFields?.find((linkField) => linkField.path === fieldStr);
+    const isRoleField = schema2.roles?.[fieldStr];
+    if (isDataField) {
+      return createDataField(field, fieldStr, justId, isDataField.dbPath, isDataField.isVirtual);
+    } else if (isLinkField) {
+      return createLinkField(field, fieldStr, isLinkField, justId, isLinkField.dbPath);
+    } else if (isRoleField) {
+      return createRoleField(field, fieldStr, isRoleField, justId, isRoleField.dbPath);
+    }
+    return null;
+  };
+  const parser = (blocks) => {
+    return produce4(
+      blocks,
+      (draft) => traverse5(draft, (context) => {
+        const { value: val } = context;
+        const value = val;
+        if (isObject5(value)) {
+          if (value.$id) {
+            const node = value.$entity || value.$relation ? value : { [`$${value.$thingType}`]: value.$thing };
+            const currentSchema = getCurrentSchema(schema, node);
+            value.$path = currentSchema.name;
+            if (!Array.isArray(value.$id)) {
+              value.$filterByUnique = true;
+            }
+            if (currentSchema?.idFields?.length === 1) {
+              const [idField] = currentSchema.idFields;
+              value.$filter = { ...value.$filter, ...{ [idField]: value.$id } };
+              delete value.$id;
+            } else {
+              throw new Error("Multiple ids not yet enabled / composite ids");
+            }
+          } else if ("$entity" in value || "$relation" in value) {
+            const currentSchema = getCurrentSchema(schema, value);
+            value.$path = currentSchema.name;
+            value.$as = currentSchema.name;
+          }
+          if (value.$entity) {
+            value.$thing = value.$entity;
+            value.$thingType = "entity";
+            delete value.$entity;
+          } else if (value.$relation) {
+            value.$thing = value.$relation;
+            value.$thingType = "relation";
+            delete value.$relation;
+          }
+          if (isObject5(value) && "$thing" in value) {
+            const node = value.$entity || value.$relation ? value : { [`$${value.$thingType}`]: value.$thing };
+            const currentSchema = getCurrentSchema(schema, node);
+            if (value.$filter) {
+              value.$filterByUnique = checkFilterByUnique(value.$filter, currentSchema);
+              if (!value.$filterProcessed) {
+                value.$filter = processFilter(value.$filter, currentSchema);
+              }
+            }
+            if (value.$fields) {
+              const idFieldIncluded = value.$fields.filter(
+                (field) => currentSchema?.idFields?.includes(field) || currentSchema?.idFields?.includes(field.$path)
+              ).length > 0;
+              if (!idFieldIncluded) {
+                value.$fields = [...value.$fields, ...currentSchema.idFields];
+                value.$idNotIncluded = true;
+              }
+              const newFields = value.$fields?.flatMap((field) => {
+                const processed = processField(field, currentSchema);
+                if (Array.isArray(processed)) {
+                  return processed;
+                } else {
+                  return [processed];
+                }
+              }).filter(Boolean);
+              value.$fields = newFields;
+            } else {
+              const allFields = getAllFields(currentSchema);
+              const newFields = allFields?.flatMap((field) => {
+                const processed = processField(field, currentSchema);
+                if (Array.isArray(processed)) {
+                  return processed;
+                } else {
+                  return [processed];
+                }
+              }).filter(Boolean);
+              value.$fields = newFields;
+            }
+            if (value.$excludedFields) {
+              value.$fields = value.$fields.filter((f) => !value.$excludedFields.includes(f.$path));
+            }
+          }
+        }
+      })
+    );
+  };
+  const enrichedBqlQuery = parser(Array.isArray(rawBqlQuery) ? rawBqlQuery : [rawBqlQuery]);
+  req.enrichedBqlQuery = enrichedBqlQuery;
+};
+
+// src/pipeline/transaction/runTQLQuery.ts
+import { TransactionType as TransactionType3 } from "typedb-driver";
+import { parallel } from "radash";
+var newRunTQLQuery = async (req, res) => {
+  const { dbHandles, enrichedBqlQuery, tqlRequest, config } = req;
+  if (!enrichedBqlQuery) {
+    throw new Error("BQL request not parsed");
+  }
+  if (!tqlRequest) {
+    throw new Error("TQL request not built");
+  }
+  const isBatched = Array.isArray(tqlRequest);
+  if (isBatched) {
+    const resArray = await parallel(tqlRequest.length, tqlRequest, async (queryString) => {
+      const { session } = await getSessionOrOpenNewOne(dbHandles, config);
+      const transaction = await session.transaction(TransactionType3.READ);
+      if (!transaction) {
+        throw new Error("Can't create transaction");
+      }
+      const tqlStream = transaction.query.fetch(queryString);
+      const tqlRes = await tqlStream.collect();
+      await transaction.close();
+      return tqlRes;
+    });
+    res.rawTqlRes = resArray;
+    res.isBatched = true;
+  } else {
+    const { session } = await getSessionOrOpenNewOne(dbHandles, config);
+    const transaction = await session.transaction(TransactionType3.READ);
+    if (!transaction) {
+      throw new Error("Can't create transaction");
+    }
+    const tqlStream = transaction.query.fetch(tqlRequest);
+    const tqlRes = await tqlStream.collect();
+    await transaction.close();
+    res.rawTqlRes = tqlRes;
+  }
+};
+
+// src/pipeline/postprocess/parseTQLQuery.ts
+var parseMetaData = (str) => {
+  const asRegex = /as:([a-zA-Z0-9_\-·]+)/;
+  const justIdRegex = /justId:([a-zA-Z0-9_\-·]+)/;
+  const idNotIncludedRegex = /idNotIncluded:([a-zA-Z0-9_\-·]+)/;
+  const filterByUniqueRegex = /filterByUnique:([a-zA-Z0-9_\-·]+)/;
+  const asMatch = str.match(asRegex);
+  const justIdMatch = str.match(justIdRegex);
+  const idNotIncludedMatch = str.match(idNotIncludedRegex);
+  const filterByUniqueMatch = str.match(filterByUniqueRegex);
+  return {
+    as: asMatch ? asMatch[1] : null,
+    justId: justIdMatch ? justIdMatch[1] : null,
+    idNotIncluded: idNotIncludedMatch ? idNotIncludedMatch[1] : null,
+    filterByUnique: filterByUniqueMatch ? filterByUniqueMatch[1] : null
+  };
+};
+var parseArrayMetadata = (str) => {
+  try {
+    const convertToJson = (str2) => {
+      let jsonString = str2.replace("$metadata:", "");
+      jsonString = jsonString.replace(/([a-zA-Z0-9_\-·]+)(?=:)/g, '"$1"');
+      jsonString = jsonString.replace(/:(\s*)([a-zA-Z0-9_\-·]+)/g, (match, p1, p2) => {
+        if (/^{.*}$/.test(p2)) {
+          return `:${p2}`;
+        } else {
+          return `:${p1}"${p2}"`;
+        }
+      });
+      jsonString = jsonString.replace(/\[([^\]]+)\]/g, (match, p1) => {
+        return `[${p1.split(",").map((s) => {
+          if (s.trim().startsWith("{") && s.trim().endsWith("}")) {
+            return s.trim();
+          } else {
+            return `"${s.trim()}"`;
+          }
+        }).join(",")}]`;
+      });
+      return jsonString;
+    };
+    const converted = convertToJson(str);
+    const parsed = JSON.parse(converted);
+    return parsed;
+  } catch (e) {
+    console.error(e);
+    return { as: [], virtual: [] };
+  }
+};
+var parseTQLQuery = async (req, res) => {
+  const { enrichedBqlQuery, rawBqlRequest, schema, config } = req;
+  const { rawTqlRes, isBatched } = res;
+  if (!enrichedBqlQuery) {
+    throw new Error("BQL request not enriched");
+  } else if (!rawTqlRes) {
+    throw new Error("TQL query not executed");
+  }
+  const parseDataFields = (dataFields, currentSchema) => {
+    const { $metaData } = dataFields;
+    const { as: $as, virtual } = parseArrayMetadata($metaData);
+    const mainDataFields = Object.entries(dataFields).filter(([key]) => key !== "type" && !key.includes("$")).map(([key, value]) => {
+      const field = currentSchema.dataFields?.find((f) => f.path === key || f.dbPath === key);
+      const isIdField = key === "id";
+      const $asKey = Array.isArray($as) ? $as.find((o) => o[key])?.[key] : key;
+      let fieldValue;
+      if (field?.cardinality === "ONE") {
+        fieldValue = value[0] ? value[0].value : config.query?.returnNulls ? null : void 0;
+        if (isIdField && !config.query?.noMetadata) {
+          return [
+            [$asKey, fieldValue],
+            ["$id", fieldValue]
+          ].filter(([_, v]) => v !== void 0);
+        }
+      } else if (field?.cardinality === "MANY") {
+        fieldValue = value.map((o) => o.value);
+      }
+      return [[$asKey, fieldValue]].filter(([_, v]) => v !== void 0);
+    }).flat();
+    const virtualFields = virtual.map((key) => {
+      const $asKey = $as.find((o) => o[key])?.[key];
+      const field = currentSchema.dataFields?.find((f) => f.isVirtual && f.dbPath === key);
+      const computedValue = compute({ currentThing: Object.fromEntries(mainDataFields), fieldSchema: field });
+      return [$asKey, computedValue];
+    });
+    return Object.fromEntries([...mainDataFields, ...virtualFields]);
+  };
+  const parseRoleFields = (roleFields) => {
+    return roleFields.reduce((roleFieldsRes, roleField) => {
+      const { $roleFields, $metaData, $cardinality } = roleField;
+      const { as, justId, idNotIncluded, filterByUnique } = parseMetaData($metaData);
+      const items = $roleFields.map((item) => {
+        const { dataFields, currentSchema, linkFields, roleFields: roleFields2, schemaValue } = parseFields(item);
+        const parsedDataFields = parseDataFields(dataFields, currentSchema);
+        if (justId === "T") {
+          return parsedDataFields.id;
+        } else {
+          const parsedLinkFields = parseLinkFields(linkFields);
+          const parsedRoleFields = parseRoleFields(roleFields2);
+          const resDataFields = { ...parsedDataFields };
+          if (idNotIncluded === "true") {
+            currentSchema?.idFields?.forEach((field) => delete resDataFields[field]);
+          }
+          return {
+            ...resDataFields,
+            ...parsedLinkFields,
+            ...parsedRoleFields,
+            ...!config.query?.noMetadata && { ...schemaValue }
+          };
+        }
+      });
+      if (items.length > 0) {
+        roleFieldsRes[as] = $cardinality === "MANY" && filterByUnique === "false" ? items : items[0];
+      } else if (config.query?.returnNulls) {
+        roleFieldsRes[as] = null;
+      }
+      return roleFieldsRes;
+    }, {});
+  };
+  const parseLinkFields = (linkFields) => {
+    return linkFields.reduce((linkFieldsRes, linkField) => {
+      const { $linkFields, $metaData, $cardinality } = linkField;
+      const { as, justId, idNotIncluded, filterByUnique } = parseMetaData($metaData);
+      const items = $linkFields.map((item) => {
+        const { dataFields, currentSchema, linkFields: linkFields2, roleFields, schemaValue } = parseFields(item);
+        const parsedDataFields = parseDataFields(dataFields, currentSchema);
+        if (justId === "T") {
+          return parsedDataFields.id;
+        } else {
+          const parsedLinkFields = parseLinkFields(linkFields2);
+          const parsedRoleFields = parseRoleFields(roleFields);
+          const resDataFields = { ...parsedDataFields };
+          if (idNotIncluded === "true") {
+            currentSchema.idFields?.forEach((field) => delete resDataFields[field]);
+          }
+          return {
+            ...resDataFields,
+            ...parsedLinkFields,
+            ...parsedRoleFields,
+            ...!config.query?.noMetadata && { ...schemaValue }
+          };
+        }
+      });
+      linkFieldsRes[as] = items.length > 0 ? $cardinality === "MANY" && filterByUnique === "false" ? items : items[0] : config.query?.returnNulls ? null : void 0;
+      return linkFieldsRes;
+    }, {});
+  };
+  const parseFields = (obj) => {
+    const keys = Object.keys(obj);
+    const dataFieldsKey = keys.find((key) => key.endsWith(".$dataFields"));
+    if (!dataFieldsKey) {
+      throw new Error("No datafields");
+    }
+    const dataFields = obj[dataFieldsKey];
+    const metaDataKey = dataFieldsKey.split(".")[dataFieldsKey.split(".").length - 2];
+    dataFields.$metaData = metaDataKey;
+    if (dataFields.length === 0) {
+      throw new Error("No datafields");
+    }
+    const dataFieldsThing = dataFields.type;
+    const schemaValue = {
+      $thing: dataFieldsThing.label,
+      $thingType: dataFieldsThing.root
+    };
+    const node = { [`$${schemaValue.$thingType}`]: schemaValue.$thing };
+    const currentSchema = getCurrentSchema(schema, node);
+    const linkFields = keys.filter(
+      (key) => !key.endsWith(".$dataFields") && currentSchema.linkFields?.some((o) => o.path === key.split(".").pop())
+    ).map((key) => ({
+      $linkFields: obj[key],
+      $key: key.split(".").pop(),
+      $metaData: key.split(".")[key.split(".").length - 2],
+      $cardinality: currentSchema?.linkFields?.find((o) => o.path === key.split(".").pop())?.cardinality
+    }));
+    const roleFields = keys.filter((key) => !key.endsWith(".$dataFields") && currentSchema.roles?.[key.split(".").pop()]).map((key) => ({
+      $roleFields: obj[key],
+      $key: key.split(".").pop(),
+      $metaData: key.split(".")[key.split(".").length - 2],
+      // @ts-expect-error todo
+      $cardinality: currentSchema.roles[key.split(".").pop()].cardinality
+    }));
+    return { dataFields, schemaValue, currentSchema, linkFields, roleFields };
+  };
+  const realParse = (tqlRes) => {
+    return tqlRes.map((resItem) => {
+      const { dataFields, currentSchema, linkFields, roleFields, schemaValue } = parseFields(resItem);
+      const parsedDataFields = parseDataFields(dataFields, currentSchema);
+      const parsedLinkFields = parseLinkFields(linkFields);
+      const parsedRoleFields = parseRoleFields(roleFields);
+      const idNotIncluded = rawBqlRequest?.$fields?.every(
+        // @ts-expect-error todo
+        (field) => !currentSchema?.idFields?.includes(field) && !currentSchema?.idFields?.includes(field.$path)
+      );
+      const finalObj = {
+        ...parsedLinkFields,
+        ...parsedRoleFields,
+        ...!config.query?.noMetadata ? { ...schemaValue } : {},
+        ...!config.query?.noMetadata && rawBqlRequest.$id ? { $id: Array.isArray(rawBqlRequest.$id) ? parsedDataFields["id"] : rawBqlRequest.$id } : {},
+        ...idNotIncluded ? Object.fromEntries(
+          Object.entries(parsedDataFields).filter(([key]) => !currentSchema?.idFields?.includes(key))
+        ) : parsedDataFields
+      };
+      return finalObj;
+    });
+  };
+  const parser = (tqlRes) => {
+    const processResponse = (resItems) => {
+      const parsedItems = realParse(resItems);
+      return rawBqlRequest.$id && !Array.isArray(rawBqlRequest.$id) || enrichedBqlQuery[0].$filterByUnique ? parsedItems[0] ?? null : parsedItems.length === 0 ? null : parsedItems;
+    };
+    return isBatched ? tqlRes.map(processResponse) : processResponse(tqlRes);
+  };
+  const parsedTqlRes = parser(rawTqlRes);
+  res.bqlRes = parsedTqlRes;
+};
+
+// src/pipeline/preprocess/newPreQuery.ts
+import { traverse as traverse6 } from "object-traversal";
+import { isObject as isObject6 } from "radash";
+import { produce as produce5 } from "immer";
+import { v4 as uuidv43 } from "uuid";
+var newPreQuery = async (req) => {
+  const { filledBqlRequest, config, schema } = req;
+  const getFieldKeys = (block, noDataFields) => {
+    return Object.keys(block).filter((key) => {
+      if (!key.startsWith("$")) {
+        if (noDataFields) {
+          const currentSchema = getCurrentSchema(schema, block);
+          if (!currentSchema.dataFields?.find((field) => field.path === key)) {
+            return true;
+          } else {
+            return false;
+          }
+        } else {
+          return true;
+        }
+      } else {
+        return false;
+      }
+    });
+  };
+  if (!filledBqlRequest) {
+    throw new Error("[BQLE-M-0] No filledBqlRequest found");
+  }
+  console.log("filledBql: ", JSON.stringify(filledBqlRequest, null, 2));
+  if (config.mutation?.preQuery === false) {
+    return;
+  }
+  const ops = [];
+  traverse6(filledBqlRequest, ({ parent, key, value }) => {
+    if (parent && key && !key.includes("$") && isObject6(parent)) {
+      const values = Array.isArray(parent[key]) ? parent[key] : [parent[key]];
+      values.forEach((val) => {
+        if (isObject6(val)) {
+          if (parent.$op !== "create") {
+            if (!ops.includes(val.$op)) {
+              ops.push(val.$op);
+            }
+          } else {
+            if (val.$op === "delete" || val.$op === "unlink") {
+              throw new Error(`Cannot ${val.$op} under a create`);
+            }
+          }
+        }
+      });
+    } else if (!parent && isObject6(value)) {
+      if (!ops.includes(value.$op)) {
+        ops.push(value.$op);
+      }
+    }
+  });
+  if (!ops.includes("delete") && !ops.includes("unlink") && !ops.includes("replace") && !ops.includes("update") && !ops.includes("link")) {
+    return;
+  }
+  const convertMutationToQuery = (blocks) => {
+    const processBlock = (block, root) => {
+      const $fields = [];
+      const filteredBlock = {};
+      const toRemoveFromRoot = ["$op", "$bzId", "$parentKey"];
+      const toRemove = ["$relation", "$entity", "$id", ...toRemoveFromRoot];
+      for (const k in block) {
+        if (toRemoveFromRoot.includes(k)) {
+          continue;
+        }
+        if (toRemove.includes(k) && !root) {
+          continue;
+        }
+        if (!k.includes("$") && (isObject6(block[k]) || Array.isArray(block[k]))) {
+          const v = block[k];
+          if (Array.isArray(v) && v.length > 0) {
+            v.forEach((opBlock) => {
+              $fields.push({
+                $path: k,
+                ...processBlock(opBlock)
+                // $as: opBlock.$bzId,
+                // $as: `${k}_${includedKeys}`,
+              });
+            });
+          } else {
+            $fields.push({
+              $path: k,
+              ...processBlock(v)
+              // $as: v.$bzId,
+            });
+          }
+        } else {
+          filteredBlock[k] = block[k];
+        }
+      }
+      return {
+        ...filteredBlock,
+        $fields
+        // $as: block.$bzId,
+      };
+    };
+    return blocks.map((block) => processBlock(block, true));
+  };
+  const preQueryReq = convertMutationToQuery(Array.isArray(filledBqlRequest) ? filledBqlRequest : [filledBqlRequest]);
+  const preQueryRes = await queryPipeline(preQueryReq, req.config, req.schema, req.dbHandles);
+  const getObjectPath = (parent, key) => {
+    const idField = parent.$id || parent.id || parent.$bzId;
+    if (parent.$objectPath) {
+      const { $objectPath } = parent;
+      const root = $objectPath?.beforePath || "root";
+      const ids = Array.isArray($objectPath.ids) ? `[${$objectPath.ids}]` : $objectPath.ids;
+      const final2 = `${root}.${ids}___${$objectPath.key}`;
+      const new$objectPath = {
+        beforePath: final2,
+        ids: idField,
+        key
+      };
+      return new$objectPath;
+    } else {
+      return {
+        beforePath: "root",
+        ids: idField,
+        key
+      };
+    }
+  };
+  const objectPathToKey = ($objectPath, hardId) => {
+    const root = $objectPath?.beforePath || "root";
+    const ids = hardId ? hardId : Array.isArray($objectPath?.ids) ? `[${$objectPath?.ids}]` : $objectPath?.ids;
+    const final2 = `${root}.${ids}___${$objectPath?.key}`;
+    return final2;
+  };
+  const convertManyPaths = (input) => {
+    if (input.includes("[") && input.includes("]")) {
+      const [prefix, itemsWithBrackets, suffix] = input.split(/[[\]]/);
+      const items = itemsWithBrackets.split(",");
+      return items.map((item) => `${prefix}${item}${suffix}`);
+    } else {
+      return [input];
+    }
+  };
+  const cache = {};
+  const cachePaths = (blocks) => {
+    return produce5(
+      blocks,
+      (draft) => traverse6(draft, (context) => {
+        const { key, parent } = context;
+        if (parent && key && parent.$id && !key.includes("$")) {
+          const newObjPath = getObjectPath(parent, key);
+          const cacheKey = objectPathToKey(newObjPath);
+          if (Array.isArray(parent[key])) {
+            const cacheArray = [];
+            parent[key].forEach((val) => {
+              if (isObject6(val)) {
+                val.$objectPath = newObjPath;
+                cacheArray.push(val.$id.toString());
+              } else if (val) {
+                cacheArray.push(val.toString());
+              }
+            });
+            cache[cacheKey] = { $objectPath: newObjPath, $ids: cacheArray };
+          } else {
+            const val = parent[key];
+            if (isObject6(val)) {
+              cache[cacheKey] = { $objectPath: newObjPath, $ids: [val.$id.toString()] };
+              val.$objectPath = newObjPath;
+            } else if (val) {
+              cache[cacheKey] = { $objectPath: newObjPath, $ids: [val.toString()] };
+            }
+          }
+        }
+      })
+    );
+  };
+  cachePaths(preQueryRes || {});
+  const fillObjectPaths = (blocks) => {
+    return produce5(
+      blocks,
+      (draft) => traverse6(draft, (context) => {
+        const { key, value, parent } = context;
+        if (parent && key && !key.includes("$") && (Array.isArray(value) || isObject6(value)) && !Array.isArray(parent)) {
+          if (Array.isArray(parent[key])) {
+            parent[key].forEach(
+              (o) => {
+                if (typeof o !== "string") {
+                  o.$objectPath = getObjectPath(parent, key);
+                  o.$parentIsCreate = parent.$op === "create";
+                  o.$grandChildOfCreate = parent.$parentIsCreate || parent.$grandChildOfCreate;
+                }
+              }
+            );
+          } else if (isObject6(parent[key])) {
+            parent[key].$parentIsCreate = parent.$op === "create";
+            parent[key].$grandChildOfCreate = parent.$parentIsCreate || parent.$grandChildOfCreate;
+            parent[key].$objectPath = getObjectPath(parent, key);
+          }
+        }
+      })
+    );
+  };
+  const bqlWithObjectPaths = fillObjectPaths(filledBqlRequest);
+  const splitBzIds = (blocks) => {
+    const processBlocks = (operationBlocks, parentOperationBlock) => {
+      let processIds = [];
+      operationBlocks.forEach((operationBlock) => {
+        const fieldCount = Object.keys(operationBlock).filter((key) => !key.startsWith("$")).length;
+        if (Array.isArray(operationBlock.$id) && fieldCount > 0) {
+          const splitBlocksById = operationBlock.$id.map((id) => {
+            return { ...operationBlock, $id: id };
+          });
+          processIds = [...processIds, ...splitBlocksById];
+        } else {
+          processIds.push(operationBlock);
+        }
+      });
+      let newOperationBlocks = [];
+      const fieldsWithoutMultiples = [];
+      const fieldsWithMultiples = processIds.filter((operationBlock) => {
+        const ops2 = ["delete", "update", "unlink"];
+        const isCorrectOp = ops2.includes(operationBlock.$op || "");
+        const fieldCount = Object.keys(operationBlock).filter((key) => !key.startsWith("$")).length;
+        const isMultiple = !operationBlock.$id || Array.isArray(operationBlock.$id) && fieldCount > 0 || operationBlock.$filter;
+        if (isMultiple && isCorrectOp) {
+          return true;
+        } else {
+          fieldsWithoutMultiples.push(operationBlock);
+        }
+      });
+      if (fieldsWithMultiples.length > 0) {
+        fieldsWithMultiples.forEach((opBlock) => {
+          const getAllKeyCombinations = (obj) => {
+            const allKeys = Object.keys(obj);
+            const combinableKeys = allKeys.filter((key) => !key.startsWith("$"));
+            const allCombinations2 = [];
+            const generateCombinations = (index, currentObj) => {
+              if (index === combinableKeys.length) {
+                const fullObj = { ...currentObj };
+                allKeys.forEach((key) => {
+                  if (key.startsWith("$")) {
+                    fullObj[key] = obj[key];
+                  }
+                });
+                allCombinations2.push(fullObj);
+                return;
+              }
+              const newObjInclude = { ...currentObj, [combinableKeys[index]]: obj[combinableKeys[index]] };
+              generateCombinations(index + 1, newObjInclude);
+              generateCombinations(index + 1, currentObj);
+            };
+            generateCombinations(0, {});
+            return allCombinations2;
+          };
+          const allCombinations = getAllKeyCombinations(opBlock).filter(
+            (opBlock2) => !(opBlock2.$op === "update" && Object.keys(opBlock2).filter((key) => !key.startsWith("$")).length === 0)
+          );
+          let included = [];
+          const emptyObjCKey = objectPathToKey(opBlock.$objectPath);
+          const cacheR = cache[emptyObjCKey];
+          let remaining = cacheR ? cache[emptyObjCKey].$ids : [];
+          const combinationsFromCache = allCombinations.map((combination, index) => {
+            const _currentSchema = getCurrentSchema(schema, combination);
+            const combinableKeys = Object.keys(combination).filter(
+              (fieldKey) => !fieldKey.includes("$") && !_currentSchema.dataFields?.some((o) => o.path === fieldKey)
+            );
+            const cachesFound = combinableKeys.map((key) => {
+              const multiples = Array.isArray(combination[key]) ? combination[key].length > 1 ? combination[key].filter(
+                (opBlock2) => !opBlock2.$id || Array.isArray(opBlock2.$id) || opBlock2.$filter
+              ) : combination[key] : [combination[key]];
+              const processedMultiples = multiples.map((multiple) => {
+                const cKey = objectPathToKey(multiple.$objectPath);
+                const getIdsToKey = (searchKey) => {
+                  const ids = [];
+                  const searchSegments = searchKey.split(".");
+                  const starting = searchSegments.slice(0, searchSegments.length - 1).join(".");
+                  const ending = searchSegments.slice(searchSegments.length - 1, searchSegments.length)[0].split("___")[1];
+                  for (const key2 in cache) {
+                    if (key2.startsWith(starting) && key2.endsWith(ending)) {
+                      const searchSegments2 = key2.split(".");
+                      const id = searchSegments2.slice(searchSegments2.length - 1, searchSegments2.length)[0].split("___")[0];
+                      ids.push(id);
+                    }
+                  }
+                  return ids;
+                };
+                const idsToKey = getIdsToKey(cKey);
+                return { idsToKey, key, multiple };
+              });
+              return processedMultiples;
+            }).filter((key) => key !== void 0);
+            const findCommonIds = (data) => {
+              const preppedArray = data.map((operations) => {
+                const ids = operations.map((operation) => {
+                  return operation.idsToKey;
+                });
+                return ids;
+              });
+              const findCommonElements = (arr) => {
+                if (arr.length > 0) {
+                  const flatArray = arr.reduce((acc, val) => acc.concat(val), []);
+                  return flatArray.reduce((acc, subArr) => {
+                    if (!acc) {
+                      return subArr;
+                    }
+                    return subArr.filter((item) => acc.includes(item));
+                  });
+                } else {
+                  return [];
+                }
+              };
+              return findCommonElements(preppedArray);
+            };
+            const commonIds = findCommonIds(cachesFound);
+            const filteredCommonIds = commonIds.filter((id) => !included.includes(id));
+            included = [...included, ...filteredCommonIds];
+            remaining = remaining.filter((id) => !filteredCommonIds.includes(id));
+            if (index === allCombinations.length - 1 && remaining.length > 0) {
+              const newOp = {
+                ...combination,
+                $id: remaining
+              };
+              return newOp;
+            } else if (filteredCommonIds.length > 0) {
+              const newOp = {
+                ...combination,
+                $id: filteredCommonIds
+              };
+              return newOp;
+            }
+          }).filter((combination) => combination !== void 0);
+          const returnFields = combinationsFromCache.length === 0 && !parentOperationBlock?.$id ? fieldsWithMultiples : combinationsFromCache;
+          newOperationBlocks = [...fieldsWithoutMultiples, ...returnFields].map(processOperationBlock);
+        });
+      } else {
+        newOperationBlocks = processIds.map(processOperationBlock);
+      }
+      return newOperationBlocks;
+    };
+    const processOperationBlock = (operationBlock) => {
+      const newBlock = { ...operationBlock, $bzId: `T_${uuidv43()}` };
+      const currentSchema = getCurrentSchema(schema, operationBlock);
+      Object.keys(operationBlock).filter((fieldKey) => !fieldKey.includes("$") && !currentSchema.dataFields?.some((o) => o.path === fieldKey)).forEach((fieldKey) => {
+        const operationBlocks = Array.isArray(operationBlock[fieldKey]) ? operationBlock[fieldKey] : [operationBlock[fieldKey]];
+        const newOperationBlocks = processBlocks(operationBlocks, operationBlock);
+        newBlock[fieldKey] = newOperationBlocks;
+      });
+      return newBlock;
+    };
+    let newBlocks = [];
+    blocks.forEach((block) => {
+      newBlocks = [...newBlocks, ...processBlocks([block])];
+    });
+    const splitBlocks = newBlocks.map(processOperationBlock);
+    return splitBlocks;
+  };
+  const splitBql = splitBzIds(Array.isArray(bqlWithObjectPaths) ? bqlWithObjectPaths : [bqlWithObjectPaths]);
+  const processReplaces = (blocks) => {
+    return blocks.map((block) => {
+      const fields = getFieldKeys(block, true);
+      const newBlock = { ...block };
+      fields.forEach((field) => {
+        const opBlocks = Array.isArray(block[field]) ? block[field] : [block[field]];
+        const newOpBlocks = [];
+        opBlocks.forEach((opBlock) => {
+          if (opBlock.$op === "replace") {
+            const cacheKey = objectPathToKey(opBlock.$objectPath);
+            const cacheKeys = convertManyPaths(cacheKey);
+            const foundKeys = cacheKeys.map((cacheKey2) => {
+              return cache[cacheKey2];
+            });
+            const cacheFound = foundKeys.length === cacheKeys.length;
+            const linksToNotInclude = [];
+            if (cacheFound) {
+              foundKeys.forEach((foundKey) => {
+                if (foundKey) {
+                  const unlinkIds = [];
+                  foundKey.$ids.filter((id) => {
+                    linksToNotInclude.push(id);
+                    return id !== opBlock.$id;
+                  }).forEach((id) => {
+                    unlinkIds.push(id);
+                  });
+                  newOpBlocks.push({ ...opBlock, $op: "unlink", $id: unlinkIds, $bzId: `T_${uuidv43()}` });
+                }
+              });
+            }
+            if (Array.isArray(opBlock.$id) ? !opBlock.$id.every((id) => linksToNotInclude.includes(id)) : (
+              // @ts-expect-error todo
+              !linksToNotInclude.includes(opBlock.$id)
+            )) {
+              newOpBlocks.push({ ...opBlock, $op: "link", $bzId: `T_${uuidv43()}` });
+            }
+          } else {
+            newOpBlocks.push(opBlock);
+          }
+        });
+        newBlock[field] = processReplaces(newOpBlocks);
+      });
+      return newBlock;
+    });
+  };
+  const processedReplaces = fillObjectPaths(processReplaces(fillObjectPaths(splitBql)));
+  const throwErrors = (blocks) => {
+    return produce5(
+      blocks,
+      (draft) => traverse6(draft, (context) => {
+        const { key, value, parent } = context;
+        if (key && parent && !key?.includes("$") && (Array.isArray(value) || isObject6(value)) && !Array.isArray(parent)) {
+          const values = Array.isArray(value) ? value : [value];
+          values.forEach((thing) => {
+            const parentSchema = getCurrentSchema(schema, parent);
+            const findCardinality = () => {
+              const dataFieldFound = parentSchema.dataFields?.find((field) => field.path === thing.$objectPath.key);
+              if (dataFieldFound) {
+                return dataFieldFound.cardinality;
+              }
+              const linkFieldFound = parentSchema.linkFields?.find((field) => field.path === thing.$objectPath.key);
+              if (linkFieldFound) {
+                return linkFieldFound.cardinality;
+              }
+              const roleFieldFound = parentSchema.roles?.[thing.$objectPath.key];
+              if (linkFieldFound) {
+                return roleFieldFound.cardinality;
+              }
+            };
+            const cacheFound = cache[objectPathToKey(thing.$objectPath)];
+            const processArrayIdsFound = (arrayOfIds, cacheOfIds) => {
+              return arrayOfIds.every((id) => cacheOfIds.includes(id));
+            };
+            const isOccupied = thing.$id ? Array.isArray(thing.$id) ? (
+              // @ts-expect-error todo
+              processArrayIdsFound(thing.$id, cacheFound.$ids)
+            ) : (
+              // @ts-expect-error todo
+              cacheFound?.$ids.includes(thing.$id)
+            ) : cacheFound;
+            const cardinality = findCardinality();
+            if (thing.$op === "link" && isOccupied && cardinality === "ONE") {
+              throw new Error(
+                `[BQLE-Q-M-2] Cannot link on:"${objectPathToKey(thing.$objectPath)}" because it is already occupied.`
+              );
+            }
+            if (thing.$op) {
+              switch (thing.$op) {
+                case "delete":
+                  if (!isOccupied) {
+                    if (!config.mutation?.ignoreNonexistingThings) {
+                      throw new Error(
+                        `[BQLE-Q-M-2] Cannot delete $id:"${thing.$id}" because it is not linked to $id:"${parent.$id}"`
+                      );
+                    } else {
+                    }
+                  }
+                  break;
+                case "update":
+                  if (!isOccupied) {
+                    if (!config.mutation?.ignoreNonexistingThings) {
+                      throw new Error(
+                        `[BQLE-Q-M-2] Cannot update $id:"${thing.$id}" because it is not linked to $id:"${parent.$id}"`
+                      );
+                    }
+                  }
+                  break;
+                case "unlink":
+                  if (!isOccupied) {
+                    if (!config.mutation?.ignoreNonexistingThings) {
+                      throw new Error(
+                        `[BQLE-Q-M-2] Cannot unlink $id:"${thing.$id}" because it is not linked to $id:"${parent.$id}"`
+                      );
+                    }
+                  }
+                  break;
+                case "link":
+                  if (isOccupied) {
+                    throw new Error(
+                      `[BQLE-Q-M-2] Cannot link $id:"${thing.$id}" because it is already linked to $id:"${parent.$id}"`
+                    );
+                  }
+                  break;
+                default:
+                  break;
+              }
+            }
+          });
+        }
+      })
+    );
+  };
+  throwErrors(processedReplaces);
+  const fillPaths = (blocks) => {
+    return produce5(
+      blocks,
+      (draft) => traverse6(draft, (context) => {
+        const { parent, key, value, meta } = context;
+        if (isObject6(value)) {
+          value[Symbol.for("path")] = meta.nodePath;
+          delete value.$objectPath;
+          delete value.$parentIsCreate;
+        }
+        if (key && parent && !key?.includes("$") && (Array.isArray(value) || isObject6(value)) && !Array.isArray(parent)) {
+          const values = Array.isArray(value) ? value : [value];
+          values.forEach((val) => {
+            if (isObject6(val)) {
+              val[Symbol.for("parent")] = {
+                // @ts-expect-error todo
+                ...value[Symbol.for("parent")],
+                path: parent[Symbol.for("path")]
+              };
+            }
+          });
+        }
+      })
+    );
+  };
+  const final = fillPaths(processedReplaces);
+  console.log("final", JSON.stringify(final, null, 2));
+  req.filledBqlRequest = final;
+};
+
+// src/pipeline/pipeline.ts
+var Pipelines = {
+  query: [enrichBQLQuery, newBuildTQLQuery, newRunTQLQuery, parseTQLQuery],
+  mutation: [
+    fillBQLMutation,
+    newPreQuery,
+    parseBQLMutation,
+    buildTQLMutation,
+    runTQLMutation,
+    parseTQLMutation,
+    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) {
+    if (req.config.query?.debugger === true && typeof res.bqlRes === "object") {
+      return { ...res.bqlRes, $debugger: { tqlRequest: req.tqlRequest } };
+    }
+    return res.bqlRes;
+  }
+  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 tryit(TypeDB.coreDriver)(dbc.url);
+          if (clientErr) {
+            const message = `[BORM:${dbc.provider}:${dbc.dbName}:core] ${// clientErr.messageTemplate?._messageBody() ?? "Can't create TypeDB Client"
+            clientErr.message ?? "Can't create TypeDB Client"}`;
+            throw new Error(message);
+          }
+          try {
+            const session = await client.session(dbc.dbName, SessionType3.DATA);
+            dbHandles.typeDB.set(dbc.id, { client, session });
+          } catch (sessionErr) {
+            const message = `[BORM:${dbc.provider}:${dbc.dbName}:session] ${// eslint-disable-next-line no-underscore-dangle
+            (sessionErr.messageTemplate?._messageBody() || sessionErr.message) ?? "Can't create TypeDB Session"}`;
+            throw new Error(message);
+          }
+        }
+        if (dbc.provider === "typeDBCluster" && dbc.dbName) {
+          const [clientErr, client] = await tryit(TypeDB.enterpriseDriver)(dbc.addresses, dbc.credentials);
+          if (clientErr) {
+            const message = `[BORM:${dbc.provider}:${dbc.dbName}:core] ${// clientErr.messageTemplate?._messageBody() ?? "Can't create TypeDB Client"
+            clientErr.message ?? "Can't create TypeDB Cluster Client"}`;
+            throw new Error(message);
+          }
+          try {
+            const session = await client.session(dbc.dbName, SessionType3.DATA);
+            dbHandles.typeDB.set(dbc.id, { client, session });
+          } catch (sessionErr) {
+            const message = `[BORM:${dbc.provider}:${dbc.dbName}:session] ${// eslint-disable-next-line no-underscore-dangle
+            (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;
+  };
+  define = async () => {
+    await this.#enforceConnection();
+    return bormDefine(this.config, this.schema, this.dbHandles);
+  };
+  /// no types yet, but we can do "as ..." after getting the type fro the 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;
+export {
+  src_default as default
+};
+//! reads all the insertions and gets the first match. This means each id must be unique
+//! disabled as it has false positives
+//# sourceMappingURL=index.mjs.map