For AI agents: the documentation index is at /stratasync/docs/llms.txt. Append .md to any page URL, or send Accept: text/markdown, for the Markdown version of that page.
For AI agents: the documentation index is at llms.txt. Markdown versions are available by appending .md to any page URL, including this page's markdown.
Filter, sort, and paginate synced models with composable query operators.
Filter, sort, and paginate models from the identity map. All queries run in-memory against locally cached data.
interface QueryOptions<T> {
where?: (item: T) => boolean;
orderBy?: (a: T, b: T) => number;
limit?:
Published with Edda
| Option | Type | Default | Description |
|---|---|---|---|
where | (item: T) => boolean | - | Filter predicate. Only items returning true are included. |
orderBy | (a: T, b: T) => number | - | Sort comparator (same as Array.sort). |
limit | number | - | Maximum results to return. |
offset | number | - | Number of results to skip. |
includeArchived | boolean | false | Include soft-deleted items (those with archivedAt). |
interface QueryResult<T> {
data: T[];
hasMore: boolean;
totalCount?: number;
}| Field | Description |
|---|---|
data | The filtered, sorted, paginated results. |
hasMore | true if more results exist beyond the limit. |
totalCount | Total count of matching items before pagination. |
import { createSyncClient } from "@stratasync/client";
// Simple filter
const result = await client.query<Task>("Task", {
where: (task) => task.projectId === "proj-123",
});
// With sorting and pagination
const result = await client.query<Task>("Task", {
where: (task) => task.status === "todo",
orderBy: (a, b) => b.priority - a.priority,
limit: 20,
offset: 0,
});
// Include archived
const result = await client.query<Task>("Task", {
includeArchived: true,
});where is a plain predicate, so filtering is ordinary JavaScript rather than a
DSL. There are no operator helpers to import.
// Equality
const open = await client.query("Task", {
where: (t) => t.status === "open",
});
// Comparison
const overdue = await client.query("Task", {
where: (t) => t.dueAt !== null && t.dueAt < Date.now(),
});
// Set membership
const mine = await client.query("Task", {
where: (t) => ["p_1", "p_2"].includes(t.projectId),
});
// Substring, case-insensitive
const matching = await client.query("Task", {
where: (t) => t.title.toLowerCase().includes("bug"),
});Combine conditions with &&, || and !:
const urgent = await client.query("Task", {
where: (t) =>
t.status === "open" && (t.priority === "high" || t.dueAt < Date.now()),
});Because the predicate is a closure, keep it stable across renders when passing
it to useQuery — an inline arrow that closes over changing values is fine,
but one that is rebuilt from unrelated state re-runs the query needlessly.
orderBy is an Array.prototype.sort comparator. There are no sort helpers to
import either.
// Single field, descending
const recent = await client.query("Task", {
orderBy: (a, b) => b.createdAt - a.createdAt,
});
// Several fields: fall through to the next when the first ties
const ordered = await client.query("Task", {
orderBy: (a, b) =>
a.priority.localeCompare(b.priority) || b.createdAt - a.createdAt,
});Queries exclude items with archivedAt by default. Set includeArchived: true to include them.
const result = await client.query<Task>("Task", {
includeArchived: true,
});To query only archived items, combine includeArchived with a where predicate:
import { and } from "@stratasync/client";
const result = await client.query<Task>("Task", {
where: (task) => Boolean(task.archivedAt),
includeArchived: true,
});