@nicia-ai/typegraph 0.4.0 → 0.5.0

package/dist/index.cjs

@@ -8547,6 +8547,23 @@ function createEdgeCollection(config) {
       }
       await deleteAll(backend);
     },
+    async findByEndpoints(from, to, options) {
+      const findOptions = {};
+      if (options?.matchOn !== void 0)
+        findOptions.matchOn = options.matchOn;
+      if (options?.props !== void 0)
+        findOptions.props = options.props;
+      const result = await config.executeFindByEndpoints(
+        kind,
+        from.kind,
+        from.id,
+        to.kind,
+        to.id,
+        backend,
+        findOptions
+      );
+      return result === void 0 ? void 0 : narrowEdge(result);
+    },
     async getOrCreateByEndpoints(from, to, props, options) {
       const getOrCreateOptions = {};
       if (options?.matchOn !== void 0)
@@ -8637,7 +8654,9 @@ function createNodeCollection(config) {
     matchesTemporalMode,
     createQuery,
     executeGetOrCreateByConstraint,
-    executeBulkGetOrCreateByConstraint
+    executeBulkGetOrCreateByConstraint,
+    executeFindByConstraint,
+    executeBulkFindByConstraint
   } = config;
   return {
     async create(props, options) {
@@ -8886,6 +8905,30 @@ function createNodeCollection(config) {
       }
       await deleteAll(backend);
     },
+    async findByConstraint(constraintName, props) {
+      const result = await executeFindByConstraint(
+        kind,
+        constraintName,
+        props,
+        backend
+      );
+      return result === void 0 ? void 0 : narrowNode(result);
+    },
+    async bulkFindByConstraint(constraintName, items) {
+      if (items.length === 0) return [];
+      const mappedItems = items.map((item) => ({
+        props: item.props
+      }));
+      const results = await executeBulkFindByConstraint(
+        kind,
+        constraintName,
+        mappedItems,
+        backend
+      );
+      return results.map(
+        (result) => result === void 0 ? void 0 : narrowNode(result)
+      );
+    },
     async getOrCreateByConstraint(constraintName, props, options) {
       const execute = async (target) => {
         const result = await executeGetOrCreateByConstraint(
@@ -9746,6 +9789,28 @@ function findMatchingEdge(rows, matchOn, inputProps) {
   }
   return { liveRow, deletedRow };
 }
+async function executeEdgeFindByEndpoints(ctx, kind, fromKind, fromId, toKind, toId, backend, options) {
+  const matchOn = options?.matchOn ?? [];
+  const props = options?.props ?? {};
+  const registration = getEdgeRegistration(ctx.graph, kind);
+  const edgeKind = registration.type;
+  if (matchOn.length > 0) {
+    validateMatchOnFields(edgeKind.schema, matchOn, kind);
+  }
+  const candidateRows = await backend.findEdgesByKind({
+    graphId: ctx.graphId,
+    kind,
+    fromKind,
+    fromId,
+    toKind,
+    toId,
+    excludeDeleted: true
+  });
+  if (candidateRows.length === 0) return void 0;
+  if (matchOn.length === 0) return rowToEdge(candidateRows[0]);
+  const { liveRow } = findMatchingEdge(candidateRows, matchOn, props);
+  return liveRow === void 0 ? void 0 : rowToEdge(liveRow);
+}
 async function executeEdgeGetOrCreateByEndpoints(ctx, kind, fromKind, fromId, toKind, toId, props, backend, options) {
   const ifExists = options?.ifExists ?? "return";
   const matchOn = options?.matchOn ?? [];
@@ -10844,6 +10909,142 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
   }
   return { node: rowToNode(existingRow), action: "found" };
 }
+async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const validatedProps = chunkLDM2AFKZ_cjs.validateNodeProps(nodeKind.schema, props, {
+    kind,
+    operation: "create"
+  });
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  if (!checkWherePredicate(constraint, validatedProps)) return void 0;
+  const key = computeUniqueKey(
+    validatedProps,
+    constraint.fields,
+    constraint.collation
+  );
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  let existingUniqueRow;
+  for (const kindToCheck of kindsToCheck) {
+    const row = await backend.checkUnique({
+      graphId: ctx.graphId,
+      nodeKind: kindToCheck,
+      constraintName: constraint.name,
+      key,
+      includeDeleted: false
+    });
+    if (row !== void 0) {
+      existingUniqueRow = row;
+      break;
+    }
+  }
+  if (existingUniqueRow === void 0) return void 0;
+  const existingRow = await backend.getNode(
+    ctx.graphId,
+    existingUniqueRow.concrete_kind,
+    existingUniqueRow.node_id
+  );
+  if (existingRow === void 0 || existingRow.deleted_at !== void 0)
+    return void 0;
+  return rowToNode(existingRow);
+}
+async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items, backend) {
+  if (items.length === 0) return [];
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  const validated = [];
+  for (const item of items) {
+    const validatedProps = chunkLDM2AFKZ_cjs.validateNodeProps(nodeKind.schema, item.props, {
+      kind,
+      operation: "create"
+    });
+    const applies = checkWherePredicate(constraint, validatedProps);
+    const key = applies ? computeUniqueKey(
+      validatedProps,
+      constraint.fields,
+      constraint.collation
+    ) : void 0;
+    validated.push({ validatedProps, key });
+  }
+  const uniqueKeys = [
+    ...new Set(
+      validated.map((v) => v.key).filter((k) => k !== void 0)
+    )
+  ];
+  const kindsToCheck = getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  const existingByKey = /* @__PURE__ */ new Map();
+  if (uniqueKeys.length > 0) {
+    for (const kindToCheck of kindsToCheck) {
+      if (backend.checkUniqueBatch === void 0) {
+        for (const key of uniqueKeys) {
+          if (existingByKey.has(key)) continue;
+          const row = await backend.checkUnique({
+            graphId: ctx.graphId,
+            nodeKind: kindToCheck,
+            constraintName: constraint.name,
+            key,
+            includeDeleted: false
+          });
+          if (row !== void 0) {
+            existingByKey.set(row.key, row);
+          }
+        }
+      } else {
+        const rows = await backend.checkUniqueBatch({
+          graphId: ctx.graphId,
+          nodeKind: kindToCheck,
+          constraintName: constraint.name,
+          keys: uniqueKeys,
+          includeDeleted: false
+        });
+        for (const row of rows) {
+          if (!existingByKey.has(row.key)) {
+            existingByKey.set(row.key, row);
+          }
+        }
+      }
+    }
+  }
+  const results = Array.from({ length: items.length });
+  const seenKeys = /* @__PURE__ */ new Map();
+  for (const [index, { key }] of validated.entries()) {
+    if (key === void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    const previousIndex = seenKeys.get(key);
+    if (previousIndex !== void 0) {
+      results[index] = results[previousIndex];
+      continue;
+    }
+    seenKeys.set(key, index);
+    const existing = existingByKey.get(key);
+    if (existing === void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      existing.concrete_kind,
+      existing.node_id
+    );
+    if (existingRow === void 0 || existingRow.deleted_at !== void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    results[index] = rowToNode(existingRow);
+  }
+  return results;
+}
 async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName, items, backend, options) {
   if (items.length === 0) return [];
   const ifExists = options?.ifExists ?? "return";
@@ -11123,6 +11324,14 @@ var Store = class {
         items,
         backend,
         options
+      ),
+      executeFindByConstraint: (kind, constraintName, props, backend) => executeNodeFindByConstraint(ctx, kind, constraintName, props, backend),
+      executeBulkFindByConstraint: (kind, constraintName, items, backend) => executeNodeBulkFindByConstraint(
+        ctx,
+        kind,
+        constraintName,
+        items,
+        backend
       )
     };
   }
@@ -11160,6 +11369,16 @@ var Store = class {
         items,
         backend,
         options
+      ),
+      executeFindByEndpoints: (kind, fromKind, fromId, toKind, toId, backend, options) => executeEdgeFindByEndpoints(
+        ctx,
+        kind,
+        fromKind,
+        fromId,
+        toKind,
+        toId,
+        backend,
+        options
       )
     };
   }
@@ -11227,6 +11446,24 @@ var Store = class {
       return fn({ nodes, edges });
     });
   }
+  // === Graph Lifecycle ===
+  /**
+   * Hard-deletes all data for this graph from the database.
+   *
+   * Removes all nodes, edges, uniqueness entries, embeddings, and schema versions
+   * for this graph's ID. No hooks, no per-row logic. Wrapped in a transaction
+   * when the backend supports it.
+   *
+   * The store is usable after clearing — new data can be created immediately.
+   */
+  async clear() {
+    const doClear = async (target) => {
+      await target.clearGraph(this.graphId);
+    };
+    await (this.#backend.capabilities.transactions ? this.#backend.transaction(async (tx) => doClear(tx)) : doClear(this.#backend));
+    this.#nodeCollections = void 0;
+    this.#edgeCollections = void 0;
+  }
   // === Lifecycle ===
   /**
    * Closes the store and releases underlying resources.