trellis 3.1.35 → 3.2.0

package/dist/chunk-7QQQNUB5.js

@@ -0,0 +1,92 @@
+// src/schema/eql.ts
+function escapeValue(v) {
+  return v.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function entitiesQuery(type, where) {
+  const conds = [`type = "${escapeValue(type)}"`];
+  for (const [k, v] of Object.entries(where ?? {})) {
+    if (v === void 0 || v === null) continue;
+    conds.push(`${k} = "${escapeValue(String(v))}"`);
+  }
+  return `find ?e where ${conds.join(" and ")}`;
+}
+
+// src/schema/resolve.ts
+function relationTargetName(r) {
+  return typeof r.target === "string" ? r.target : r.target().type;
+}
+function relationTargetSchema(r) {
+  return typeof r.target === "string" ? null : r.target();
+}
+function inverseForeignKey(parent, relationName, child) {
+  for (const [key, r] of Object.entries(child.relations)) {
+    if (relationTargetName(r) === parent.type) return key;
+  }
+  return null;
+}
+async function loadByIds(client, ids, cache) {
+  const missing = ids.filter((id) => !cache.has(id));
+  if (missing.length === 0) return;
+  await Promise.all(
+    missing.map(async (id) => {
+      cache.set(id, await client.read(id));
+    })
+  );
+}
+async function resolveReverseMany(client, parent, relationName, parents, cache) {
+  const rel = parent.relations[relationName];
+  if (!rel || rel.cardinality !== "many") return;
+  const childSchema = relationTargetSchema(rel);
+  if (!childSchema) return;
+  const foreignKey = inverseForeignKey(parent, relationName, childSchema);
+  if (!foreignKey) return;
+  const parentIds = new Set(parents.map((p) => p.id));
+  const qr = await client.query(entitiesQuery(childSchema.type));
+  const childIds = qr.bindings.map((b) => b.e).filter((id) => Boolean(id));
+  await loadByIds(client, childIds, cache);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const id of childIds) {
+    const child = cache.get(id);
+    if (!child) continue;
+    const fk = child[foreignKey];
+    if (typeof fk !== "string" || !parentIds.has(fk)) continue;
+    if (!grouped.has(fk)) grouped.set(fk, []);
+    grouped.get(fk).push(child);
+  }
+  for (const row of parents) {
+    row[relationName] = grouped.get(row.id) ?? [];
+  }
+}
+async function resolveForwardOne(client, parents, relationName, cache) {
+  const ids = parents.map((p) => p[relationName]).filter((v) => typeof v === "string" && v.length > 0);
+  await loadByIds(client, ids, cache);
+  for (const row of parents) {
+    const ref = row[relationName];
+    if (typeof ref !== "string") continue;
+    const loaded = cache.get(ref);
+    if (loaded) row[relationName] = loaded;
+  }
+}
+async function resolveRelations(client, schema, entities, spec) {
+  if (entities.length === 0 || Object.keys(spec).length === 0) return entities;
+  const cache = /* @__PURE__ */ new Map();
+  const rows = entities.map((e) => ({ ...e }));
+  for (const [name, enabled] of Object.entries(spec)) {
+    if (!enabled) continue;
+    const rel = schema.relations[name];
+    if (!rel) continue;
+    if (rel.cardinality === "many") {
+      await resolveReverseMany(client, schema, name, rows, cache);
+    } else {
+      await resolveForwardOne(client, rows, name, cache);
+    }
+  }
+  return rows;
+}
+
+export {
+  escapeValue,
+  entitiesQuery,
+  inverseForeignKey,
+  resolveRelations
+};