@_linked/core 2.0.0 → 2.2.0-next.20260313111019

package/CHANGELOG.md

@@ -1,193 +1,55 @@
 # Changelog
 
-## 2.0.0
-
-### Major Changes
-
-- [#23](https://github.com/Semantu/linked/pull/23) [`d2d1eca`](https://github.com/Semantu/linked/commit/d2d1eca3517af11f39348dc83ba5e60703ef86d2) Thanks [@flyon](https://github.com/flyon)! - ## Breaking Changes
-
-  ### `Shape.select()` and `Shape.update()` no longer accept an ID as the first argument
-
-  Use `.for(id)` to target a specific entity instead.
-
-  **Select:**
-
-  ```typescript
-  // Before
-  const result = await Person.select({ id: "..." }, (p) => p.name);
-
-  // After
-  const result = await Person.select((p) => p.name).for({ id: "..." });
-  ```
-
-  `.for(id)` unwraps the result type from array to single object, matching the old single-subject overload behavior.
-
-  **Update:**
-
-  ```typescript
-  // Before
-  const result = await Person.update({ id: "..." }, { name: "Alice" });
-
-  // After
-  const result = await Person.update({ name: "Alice" }).for({ id: "..." });
-  ```
-
-  `Shape.selectAll(id)` also no longer accepts an id — use `Person.selectAll().for(id)`.
-
-  ### `ShapeType` renamed to `ShapeConstructor`
-
-  The type alias for concrete Shape subclass constructors has been renamed. Update any imports or references:
-
-  ```typescript
-  // Before
-  import type { ShapeType } from "@_linked/core/shapes/Shape";
-
-  // After
-  import type { ShapeConstructor } from "@_linked/core/shapes/Shape";
-  ```
-
-  ### `QueryString`, `QueryNumber`, `QueryBoolean`, `QueryDate` classes removed
-
-  These have been consolidated into a single generic `QueryPrimitive<T>` class. If you were using `instanceof` checks against these classes, use `instanceof QueryPrimitive` instead and check the value's type.
-
-  ### Internal IR types removed
-
-  The following types and functions have been removed from `SelectQuery`. These were internal pipeline types — if you were using them for custom store integrations, the replacement is `FieldSetEntry[]` (available from `FieldSet`):
-
-  - Types: `SelectPath`, `QueryPath`, `CustomQueryObject`, `SubQueryPaths`, `ComponentQueryPath`
-  - Functions: `fieldSetToSelectPath()`, `entryToQueryPath()`
-  - Methods: `QueryBuilder.getQueryPaths()`, `BoundComponent.getComponentQueryPaths()`
-  - `RawSelectInput.select` field renamed to `RawSelectInput.entries` (type changed from `SelectPath` to `FieldSetEntry[]`)
-
-  ### `getPackageShape()` return type is now nullable
-
-  Returns `ShapeConstructor | undefined` instead of `typeof Shape`. Code that didn't null-check the return value will now get TypeScript errors.
-
-  ## New Features
-
-  ### `.for(id)` and `.forAll(ids)` chaining
-
-  Consistent API for targeting entities across select and update operations:
-
-  ```typescript
-  // Single entity (result is unwrapped, not an array)
-  await Person.select((p) => p.name).for({ id: "..." });
-  await Person.select((p) => p.name).for("https://...");
-
-  // Multiple specific entities
-  await QueryBuilder.from(Person)
-    .select((p) => p.name)
-    .forAll([{ id: "..." }, { id: "..." }]);
-
-  // All instances (default — no .for() needed)
-  await Person.select((p) => p.name);
-  ```
-
-  ### Dynamic Query Building with `QueryBuilder` and `FieldSet`
-
-  Build queries programmatically at runtime — for CMS dashboards, API endpoints, configurable reports. See the [Dynamic Query Building](./README.md#dynamic-query-building) section in the README for full documentation and examples.
-
-  Key capabilities:
-
-  - `QueryBuilder.from(Person)` or `QueryBuilder.from('https://schema.org/Person')` — fluent, chainable, immutable query construction
-  - `FieldSet.for(Person, ['name', 'knows'])` — composable field selections with `.add()`, `.remove()`, `.pick()`, `FieldSet.merge()`
-  - `FieldSet.all(Person, {depth: 2})` — select all decorated properties with optional depth
-  - JSON serialization: `query.toJSON()` / `QueryBuilder.fromJSON(json)` and `fieldSet.toJSON()` / `FieldSet.fromJSON(json)`
-  - All builders are `PromiseLike` — `await` them directly or call `.build()` to inspect the IR
-
-  ### Mutation Builders
-
-  `CreateBuilder`, `UpdateBuilder`, and `DeleteBuilder` provide the programmatic equivalent of `Person.create()`, `Person.update()`, and `Person.delete()`, accepting Shape classes or shape IRI strings. See the [Mutation Builders](./README.md#mutation-builders) section in the README.
-
-  ### `PropertyPath` exported
-
-  The `PropertyPath` value object is now a public export — a type-safe representation of a sequence of property traversals through a shape graph.
-
-  ```typescript
-  import { PropertyPath, walkPropertyPath } from "@_linked/core";
-  ```
-
-  ### `ShapeConstructor<S>` type
-
-  New concrete constructor type for Shape subclasses. Eliminates ~30 `as any` casts across the codebase and provides better type safety at runtime boundaries (builder `.from()` methods, Shape static methods).
-
-## 1.3.0
+## 2.2.0
 
 ### Minor Changes
 
-- [#20](https://github.com/Semantu/linked/pull/20) [`33e9fb0`](https://github.com/Semantu/linked/commit/33e9fb0205343eca8c84723cbabc3f3342e40be5) Thanks [@flyon](https://github.com/flyon)! - **Breaking:** `QueryParser` has been removed. If you imported `QueryParser` directly, replace with `getQueryDispatch()` from `@_linked/core/queries/queryDispatch`. The Shape DSL (`Shape.select()`, `.create()`, `.update()`, `.delete()`) and `SelectQuery.exec()` are unchanged.
-
-  **New:** `getQueryDispatch()` and `setQueryDispatch()` are now exported, allowing custom query dispatch implementations (e.g. for testing or alternative storage backends) without subclassing `LinkedStorage`.
-
-## 1.2.1
+- [#31](https://github.com/Semantu/linked/pull/31) [`eb88865`](https://github.com/Semantu/linked/commit/eb8886564f2c9663805c4308a834ca615f9a1dab) Thanks [@flyon](https://github.com/flyon)! - Properties in `select()` and `update()` now support expressions — you can compute values dynamically instead of just reading or writing raw fields.
 
-### Patch Changes
+  ### What's new
 
-- [#17](https://github.com/Semantu/linked/pull/17) [`0654780`](https://github.com/Semantu/linked/commit/06547807a7bae56e992eba73263f83e092b7788b) Thanks [@flyon](https://github.com/flyon)! - Preserve nested array sub-select branches in canonical IR so `build()` emits complete traversals, projection fields, and `resultMap` entries for nested selections.
+  - **Computed fields in queries** — chain expression methods on properties to derive new values: string manipulation (`.strlen()`, `.ucase()`, `.concat()`), arithmetic (`.plus()`, `.times()`, `.abs()`), date extraction (`.year()`, `.month()`, `.hours()`), and comparisons (`.gt()`, `.eq()`, `.contains()`).
 
-  This fixes cases where nested branches present in `toRawInput().select` were dropped during desugar/lowering (for example nested `friends.select([name, hobby])` branches under another sub-select).
-
-  Also adds regression coverage for desugar preservation, IR lowering completeness, and updated SPARQL golden output for nested query fixtures.
-
-## 1.2.0
-
-### Minor Changes
-
-- [#9](https://github.com/Semantu/linked/pull/9) [`381067b`](https://github.com/Semantu/linked/commit/381067b0fbc25f4a0446c5f8cc0eec57ddded466) Thanks [@flyon](https://github.com/flyon)! - Replaced internal query representation with a canonical backend-agnostic IR AST. `SelectQuery`, `CreateQuery`, `UpdateQuery`, and `DeleteQuery` are now typed IR objects with `kind` discriminators, compact shape/property ID references, and expression trees — replacing the previous ad-hoc nested arrays. The public Shape DSL is unchanged; what changed is what `IQuadStore` implementations receive. Store result types (`ResultRow`, `SelectResult`, `CreateResult`, `UpdateResult`) are now exported. All factories expose `build()` as the primary method. See `documentation/intermediate-representation.md` for the full IR reference and migration guidance.
-
-- [#14](https://github.com/Semantu/linked/pull/14) [`b65e156`](https://github.com/Semantu/linked/commit/b65e15688ac173478e58e1dbb9f26dbaf5fc5a37) Thanks [@flyon](https://github.com/flyon)! - Add SPARQL conversion layer — compiles Linked IR queries into executable SPARQL and maps results back to typed DSL objects.
-
-  **New exports from `@_linked/core/sparql`:**
-
-  - **`SparqlStore`** — abstract base class for SPARQL-backed stores. Extend it and implement two methods to connect any SPARQL 1.1 endpoint:
-
-    ```ts
-    import { SparqlStore } from "@_linked/core/sparql";
-
-    class MyStore extends SparqlStore {
-      protected async executeSparqlSelect(
-        sparql: string
-      ): Promise<SparqlJsonResults> {
-        /* ... */
-      }
-      protected async executeSparqlUpdate(sparql: string): Promise<void> {
-        /* ... */
-      }
-    }
+    ```typescript
+    await Person.select((p) => ({
+      name: p.name,
+      nameLen: p.name.strlen(),
+      ageInMonths: p.age.times(12),
+    }));
     ```
 
-  - **IR → SPARQL string** convenience functions (full pipeline in one call):
-
-    - `selectToSparql(query, options?)` — SelectQuery → SPARQL string
-    - `createToSparql(query, options?)` — CreateQuery → SPARQL string
-    - `updateToSparql(query, options?)` — UpdateQuery → SPARQL string
-    - `deleteToSparql(query, options?)` — DeleteQuery → SPARQL string
+  - **Expression-based WHERE filters** — filter using computed conditions, not just equality checks. Works on queries, updates, and deletes.
 
-  - **IR → SPARQL algebra** (for stores that want to inspect/optimize the algebra before serialization):
-
-    - `selectToAlgebra(query, options?)` — returns `SparqlSelectPlan`
-    - `createToAlgebra(query, options?)` — returns `SparqlInsertDataPlan`
-    - `updateToAlgebra(query, options?)` — returns `SparqlDeleteInsertPlan`
-    - `deleteToAlgebra(query, options?)` — returns `SparqlDeleteInsertPlan`
+    ```typescript
+    await Person.select((p) => p.name).where((p) => p.name.strlen().gt(5));
+    await Person.update({ verified: true }).where((p) => p.age.gte(18));
+    ```
 
-  - **Algebra → SPARQL string** serialization:
+  - **Computed updates** — when updating data, calculate new values based on existing ones instead of providing static values. Pass a callback to `update()` to reference current field values.
 
-    - `selectPlanToSparql(plan, options?)`, `insertDataPlanToSparql(plan, options?)`, `deleteInsertPlanToSparql(plan, options?)`, `deleteWherePlanToSparql(plan, options?)`
-    - `serializeAlgebraNode(node)`, `serializeExpression(expr)`, `serializeTerm(term)`
+    ```typescript
+    await Person.update((p) => ({ age: p.age.plus(1) })).for(entity);
+    await Person.update((p) => ({
+      label: p.firstName.concat(" ").concat(p.lastName),
+    })).for(entity);
+    ```
 
-  - **Result mapping** (SPARQL JSON results → typed DSL objects):
+  - **`Expr` module** — for expressions that don't start from a property, like the current timestamp, conditional logic, or coalescing nulls.
 
-    - `mapSparqlSelectResult(json, query)` — handles flat/nested/aggregated results with XSD type coercion
-    - `mapSparqlCreateResult(uri, query)` — echoes created fields with generated URI
-    - `mapSparqlUpdateResult(query)` — echoes updated fields
+    ```typescript
+    await Person.update({ lastSeen: Expr.now() }).for(entity);
+    await Person.select((p) => ({
+      displayName: Expr.firstDefined(p.nickname, p.name),
+    }));
+    ```
 
-  - **All algebra types** re-exported: `SparqlTerm`, `SparqlTriple`, `SparqlAlgebraNode`, `SparqlExpression`, `SparqlSelectPlan`, `SparqlInsertDataPlan`, `SparqlDeleteInsertPlan`, `SparqlDeleteWherePlan`, `SparqlPlan`, `SparqlOptions`, etc.
+  Update expression callbacks are fully typed — `.plus()` only appears on number properties, `.strlen()` only on strings, etc.
 
-  **Bug fixes included:**
+  ### New exports
 
-  - Fixed `isNodeReference()` in MutationQuery.ts — nested creates with predefined IDs (e.g., `{id: '...', name: 'Bestie'}`) now correctly insert entity data instead of only creating the link.
+  `ExpressionNode`, `Expr`, `ExpressionInput`, `PropertyRefMap`, `ExpressionUpdateProxy<S>`, `ExpressionUpdateResult<S>`, and per-type method interfaces (`NumericExpressionMethods`, `StringExpressionMethods`, `DateExpressionMethods`, `BooleanExpressionMethods`, `BaseExpressionMethods`).
 
-  See [SPARQL Algebra Layer docs](./documentation/sparql-algebra.md) for the full type reference, conversion rules, and store implementation guide.
+  See the [README](./README.md#computed-expressions) for the full method reference and more examples.
 
 ## 1.1.0
 

package/README.md

@@ -56,14 +56,26 @@ Shape class → DSL query → IR (AST) → Target query language → Execute →
 Shape classes use decorators to generate SHACL metadata. These shapes define the data model, drive the DSL's type safety, and can be synced to a store for runtime data validation.
 
 ```typescript
+import {createNameSpace} from '@_linked/core/utils/NameSpace';
+
+const ns = createNameSpace('https://example.org/');
+
+// Example ontology references
+const ex = {
+  Person: ns('Person'),
+  name: ns('name'),
+  knows: ns('knows'),
+  // ... rest of your ontology
+};
+
 @linkedShape
 export class Person extends Shape {
-  static targetClass = schema('Person');
+  static targetClass = ex.Person;
 
-  @literalProperty({path: schema('name'), maxCount: 1})
+  @literalProperty({path: ex.name, maxCount: 1})
   get name(): string { return ''; }
 
-  @objectProperty({path: schema('knows'), shape: Person})
+  @objectProperty({path: ex.knows, shape: Person})
   get friends(): ShapeSet<Person> { return null; }
 }
 ```
@@ -202,19 +214,24 @@ import {literalProperty, objectProperty} from '@_linked/core/shapes/SHACL';
 import {createNameSpace} from '@_linked/core/utils/NameSpace';
 import {linkedShape} from './package';
 
-const schema = createNameSpace('https://schema.org/');
-const PersonClass = schema('Person');
-const name = schema('name');
-const knows = schema('knows');
+const ns = createNameSpace('https://example.org/');
+
+// Example ontology references
+const ex = {
+  Person: ns('Person'),
+  name: ns('name'),
+  knows: ns('knows'),
+  // ... rest of your ontology
+};
 
 @linkedShape
 export class Person extends Shape {
-  static targetClass = PersonClass;
+  static targetClass = ex.Person;
 
-  @literalProperty({path: name, required: true, maxCount: 1})
+  @literalProperty({path: ex.name, required: true, maxCount: 1})
   declare name: string;
 
-  @objectProperty({path: knows, shape: Person})
+  @objectProperty({path: ex.knows, shape: Person})
   declare knows: ShapeSet<Person>;
 }
 ```
@@ -246,9 +263,7 @@ const allFriends = await Person.select((p) => p.knows.selectAll());
 
 **3) Apply a simple mutation**
 ```typescript
-const updated = await Person.update({
-  name: 'Alicia',
-}).for({id: 'https://my.app/node1'});
+const updated = await Person.update({name: 'Alicia'}).for({id: 'https://my.app/node1'});
 /* updated: {id: string} & UpdatePartial<Person> */
 ```
 
@@ -290,11 +305,16 @@ The query DSL is schema-parameterized: you define your own SHACL shapes, and Lin
 - Outer `where(...)` chaining
 - Counting with `.size()`
 - Custom result formats (object mapping)
+- Computed values — derive new fields with arithmetic, string, date, and comparison methods
+- Expression-based WHERE filters (`p.name.strlen().gt(5)`)
+- Standalone expressions with `Expr` — timestamps, conditionals, null coalescing
 - Type casting with `.as(Shape)`
+- MINUS exclusion (by shape, property, condition, multi-property, nested path)
 - Sorting, limiting, and `.one()`
 - Query context variables
 - Preloading (`preloadFor`) for component-like queries
-- Create / Update / Delete mutations
+- Create / Update / Delete mutations (including bulk and conditional)
+- Expression-based updates (`p => ({age: p.age.plus(1)})`)
 - Dynamic query building with `QueryBuilder`
 - Composable field sets with `FieldSet`
 - Mutation builders (`CreateBuilder`, `UpdateBuilder`, `DeleteBuilder`)
@@ -403,16 +423,122 @@ const custom = await Person.select((p) => ({
 }));
 ```
 
+#### Computed expressions
+
+You can compute derived values directly in your queries — string manipulation, arithmetic, date extraction, and more. Expression methods chain naturally left-to-right.
+
+```typescript
+// String length as a computed field
+const withLen = await Person.select((p) => ({
+  name: p.name,
+  nameLen: p.name.strlen(),
+}));
+
+// Arithmetic chaining (left-to-right, no hidden precedence)
+const withAge = await Person.select((p) => ({
+  name: p.name,
+  ageInMonths: p.age.times(12),
+  agePlusTen: p.age.plus(10).times(2),  // (age + 10) * 2
+}));
+
+// String manipulation
+const upper = await Person.select((p) => ({
+  shout: p.name.ucase(),
+  greeting: p.name.concat(' says hello'),
+}));
+
+// Date extraction
+const birthYear = await Person.select((p) => ({
+  year: p.birthDate.year(),
+}));
+```
+
+**Expression methods by type:**
+
+| Type | Methods |
+|------|---------|
+| **Numeric** | `plus`, `minus`, `times`, `divide`, `abs`, `round`, `ceil`, `floor`, `power` |
+| **String** | `concat`, `contains`, `startsWith`, `endsWith`, `substr`, `before`, `after`, `replace`, `ucase`, `lcase`, `strlen`, `encodeForUri`, `matches` |
+| **Date** | `year`, `month`, `day`, `hours`, `minutes`, `seconds`, `timezone`, `tz` |
+| **Boolean** | `and`, `or`, `not` |
+| **Comparison** | `eq`, `neq`, `gt`, `gte`, `lt`, `lte` |
+| **Null-handling** | `isDefined`, `isNotDefined`, `defaultTo` |
+| **Type** | `str`, `iri`, `isIri`, `isLiteral`, `isBlank`, `isNumeric`, `lang`, `datatype` |
+| **Hash** | `md5`, `sha256`, `sha512` |
+
+#### Expression-based WHERE filters
+
+Expressions can be used in `where()` clauses for computed filtering:
+
+```typescript
+// Filter by string length
+const longNames = await Person.select((p) => p.name)
+  .where((p) => p.name.strlen().gt(5));
+
+// Filter by arithmetic
+const young = await Person.select((p) => p.name)
+  .where((p) => p.age.plus(10).lt(100));
+
+// Chain expressions with and/or
+const filtered = await Person.select((p) => p.name)
+  .where((p) => p.name.strlen().gt(3).and(p.age.gt(18)));
+
+// Expression WHERE on nested paths
+const deep = await Person.select((p) => p.name)
+  .where((p) => p.bestFriend.name.strlen().gt(3));
+
+// Expression WHERE on mutations
+await Person.update({status: 'senior'}).where((p) => p.age.plus(10).gt(65));
+```
+
+#### `Expr` module
+
+Some expressions don't belong to a specific property — like getting the current timestamp, picking the first non-null value, or conditional logic. Use the `Expr` module for these:
+
+```typescript
+import {Expr} from '@_linked/core';
+
+// Current timestamp
+const withTimestamp = await Person.update({lastSeen: Expr.now()}).for(entity);
+
+// Conditional expressions
+const labeled = await Person.select((p) => ({
+  label: Expr.ifThen(p.age.gt(18), 'adult', 'minor'),
+}));
+
+// First non-null value
+const display = await Person.select((p) => ({
+  display: Expr.firstDefined(p.name, p.nickNames, Expr.str('Unknown')),
+}));
+```
+
 #### Query As (type casting to a sub shape)
-If person.pets returns an array of Pets. And Dog extends Pet.
-And you want to select properties of those pets that are dogs:
+Cast to a subtype when you know the concrete shape — for example, selecting dog-specific properties from a pets collection:
 ```typescript
 const guards = await Person.select((p) => p.pets.as(Dog).guardDogLevel);
 ```
 
+#### MINUS (exclusion)
+```typescript
+// Exclude by shape — all Persons that are NOT also Employees
+const nonEmployees = await Person.select((p) => p.name).minus(Employee);
+
+// Exclude by property existence — Persons that do NOT have a hobby
+const noHobby = await Person.select((p) => p.name).minus((p) => p.hobby);
+
+// Exclude by multiple properties — Persons missing BOTH hobby AND nickNames
+const sparse = await Person.select((p) => p.name).minus((p) => [p.hobby, p.nickNames]);
+
+// Exclude by nested path — Persons whose bestFriend does NOT have a name
+const unnamed = await Person.select((p) => p.name).minus((p) => [p.bestFriend.name]);
+
+// Exclude by condition — Persons whose hobby is NOT 'Chess'
+const noChess = await Person.select((p) => p.name).minus((p) => p.hobby.equals('Chess'));
+```
+
 #### Sorting, limiting, one
 ```typescript
-const sorted = await Person.select((p) => p.name).sortBy((p) => p.name, 'ASC');
+const sorted = await Person.select((p) => p.name).orderBy((p) => p.name, 'ASC');
 const limited = await Person.select((p) => p.name).limit(1);
 const single = await Person.select((p) => p.name).one();
 ```
@@ -447,8 +573,10 @@ Where UpdatePartial<Shape> reflects the created properties.
 
 #### Update
 
-Update will patch any property that you send as payload and leave the rest untouched. Chain `.for(id)` to target the entity:
+Update will patch any property that you send as payload and leave the rest untouched. The data to update is required:
+
 ```typescript
+// Target a specific entity with .for(id)
 /* Result: {id: string} & UpdatePartial<Person> */
 const updated = await Person.update({name: 'Alicia'}).for({id: 'https://my.app/node1'});
 ```
@@ -460,6 +588,38 @@ Returns:
 }
 ```
 
+**Expression-based updates:**
+
+Instead of static values, you can compute new values from existing ones. Pass a callback to reference the entity's current properties:
+
+```typescript
+// Increment age by 1
+await Person.update((p) => ({age: p.age.plus(1)})).for({id: 'https://my.app/node1'});
+
+// Uppercase a name
+await Person.update((p) => ({name: p.name.ucase()})).for({id: 'https://my.app/node1'});
+
+// Reference related entity properties
+await Person.update((p) => ({hobby: p.bestFriend.name.ucase()})).for({id: 'https://my.app/node1'});
+
+// Mix literals and expressions
+await Person.update((p) => ({name: 'Bob', age: p.age.plus(1)})).for({id: 'https://my.app/node1'});
+
+// Use Expr module values directly in plain objects
+await Person.update({lastSeen: Expr.now()}).for({id: 'https://my.app/node1'});
+```
+
+The callback is type-safe — `.plus()` only appears on number properties, `.ucase()` only on strings, etc.
+
+**Conditional and bulk updates:**
+```typescript
+// Update all matching entities
+const archived = await Person.update({status: 'archived'}).where(p => p.status.equals('inactive'));
+
+// Update all instances of a shape
+await Person.update({verified: true}).forAll();
+```
+
 **Updating multi-value properties**
 When updating a property that holds multiple values (one that returns an array in the results), you can either overwrite all the values with a new explicit array of values, or delete from/add to the current values.
 
@@ -503,27 +663,19 @@ This returns an object with the added and removed items
 
 
 #### Delete
-To delete a node entirely:
 
 ```typescript
-/* Result: {deleted: Array<{id: string}>, count: number} */
+// Delete a single node
 const deleted = await Person.delete({id: 'https://my.app/node1'});
-```
-Returns
-```json
-{
-  deleted:[
-    {id:"https://my.app/node1"}
-  ],
-  count:1
-}
-```
 
-To delete multiple nodes pass an array:
+// Delete multiple nodes
+const deleted = await Person.delete([{id: 'https://my.app/node1'}, {id: 'https://my.app/node2'}]);
 
-```typescript
-/* Result: {deleted: Array<{id: string}>, count: number} */
-const deleted = await Person.delete([{id: 'https://my.app/node1'},{id: 'https://my.app/node2'}]);
+// Delete all instances of a shape (with blank node cleanup)
+await Person.deleteAll();
+
+// Conditional delete
+await Person.deleteWhere(p => p.status.equals('inactive'));
 ```
 
 
@@ -534,23 +686,17 @@ This example assumes `Person` from the `Shapes` section above.
 
 ```typescript
 import {literalProperty} from '@_linked/core/shapes/SHACL';
-import {createNameSpace} from '@_linked/core/utils/NameSpace';
 import {linkedShape} from './package';
 
-const schema = createNameSpace('https://schema.org/');
-const EmployeeClass = schema('Employee');
-const name = schema('name');
-const employeeId = schema('employeeId');
-
 @linkedShape
 export class Employee extends Person {
-  static targetClass = EmployeeClass;
+  static targetClass = ex.Employee;
 
   // Override inherited "name" with stricter constraints (still maxCount: 1)
-  @literalProperty({path: name, required: true, minLength: 2, maxCount: 1})
+  @literalProperty({path: ex.name, required: true, minLength: 2, maxCount: 1})
   declare name: string;
 
-  @literalProperty({path: employeeId, required: true, maxCount: 1})
+  @literalProperty({path: ex.employeeId, required: true, maxCount: 1})
   declare employeeId: string;
 }
 ```
@@ -716,8 +862,14 @@ const updated = await UpdateBuilder.from(Person)
   .for({id: 'https://my.app/alice'})
   .set({name: 'Alicia'});
 
-// Delete — equivalent to Person.delete({id: '...'})
-const deleted = await DeleteBuilder.from(Person).for({id: 'https://my.app/alice'});
+// Delete by ID — equivalent to Person.delete({id: '...'})
+const deleted = await DeleteBuilder.from(Person, {id: 'https://my.app/alice'});
+
+// Delete all — equivalent to Person.deleteAll()
+await DeleteBuilder.from(Person).all();
+
+// Conditional update — equivalent to Person.update({...}).where(fn)
+await UpdateBuilder.from(Person).set({verified: true}).forAll();
 
 // All builders are PromiseLike — await them or call .build() for the IR
 const ir = CreateBuilder.from(Person).set({name: 'Alice'}).build();

package/lib/cjs/expressions/Expr.d.ts

@@ -0,0 +1,58 @@
+import { ExpressionNode } from './ExpressionNode.js';
+import type { ExpressionInput } from './ExpressionNode.js';
+export declare const Expr: {
+    readonly plus: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly minus: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly times: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly divide: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly abs: (a: ExpressionInput) => ExpressionNode;
+    readonly round: (a: ExpressionInput) => ExpressionNode;
+    readonly ceil: (a: ExpressionInput) => ExpressionNode;
+    readonly floor: (a: ExpressionInput) => ExpressionNode;
+    readonly power: (a: ExpressionInput, b: number) => ExpressionNode;
+    readonly eq: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly neq: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly gt: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly gte: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly lt: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly lte: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly concat: (...parts: ExpressionInput[]) => ExpressionNode;
+    readonly contains: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly startsWith: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly endsWith: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly substr: (a: ExpressionInput, start: number, len?: number) => ExpressionNode;
+    readonly before: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly after: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly replace: (a: ExpressionInput, pat: string, rep: string, flags?: string) => ExpressionNode;
+    readonly ucase: (a: ExpressionInput) => ExpressionNode;
+    readonly lcase: (a: ExpressionInput) => ExpressionNode;
+    readonly strlen: (a: ExpressionInput) => ExpressionNode;
+    readonly encodeForUri: (a: ExpressionInput) => ExpressionNode;
+    readonly regex: (a: ExpressionInput, pat: string, flags?: string) => ExpressionNode;
+    readonly now: () => ExpressionNode;
+    readonly year: (a: ExpressionInput) => ExpressionNode;
+    readonly month: (a: ExpressionInput) => ExpressionNode;
+    readonly day: (a: ExpressionInput) => ExpressionNode;
+    readonly hours: (a: ExpressionInput) => ExpressionNode;
+    readonly minutes: (a: ExpressionInput) => ExpressionNode;
+    readonly seconds: (a: ExpressionInput) => ExpressionNode;
+    readonly timezone: (a: ExpressionInput) => ExpressionNode;
+    readonly tz: (a: ExpressionInput) => ExpressionNode;
+    readonly and: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly or: (a: ExpressionInput, b: ExpressionInput) => ExpressionNode;
+    readonly not: (a: ExpressionInput) => ExpressionNode;
+    readonly firstDefined: (...args: ExpressionInput[]) => ExpressionNode;
+    readonly ifThen: (cond: ExpressionInput, thenVal: ExpressionInput, elseVal: ExpressionInput) => ExpressionNode;
+    readonly bound: (a: ExpressionInput) => ExpressionNode;
+    readonly lang: (a: ExpressionInput) => ExpressionNode;
+    readonly datatype: (a: ExpressionInput) => ExpressionNode;
+    readonly str: (a: ExpressionInput) => ExpressionNode;
+    readonly iri: (a: ExpressionInput) => ExpressionNode;
+    readonly isIri: (a: ExpressionInput) => ExpressionNode;
+    readonly isLiteral: (a: ExpressionInput) => ExpressionNode;
+    readonly isBlank: (a: ExpressionInput) => ExpressionNode;
+    readonly isNumeric: (a: ExpressionInput) => ExpressionNode;
+    readonly md5: (a: ExpressionInput) => ExpressionNode;
+    readonly sha256: (a: ExpressionInput) => ExpressionNode;
+    readonly sha512: (a: ExpressionInput) => ExpressionNode;
+};