@_linked/core 1.3.0 → 2.0.0-next.20260310082533

package/CHANGELOG.md

@@ -1,27 +1,122 @@
 # Changelog
 
-## 1.3.0
+## 2.0.0
 
-### Minor Changes
+### Major 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.
+- [#23](https://github.com/Semantu/linked/pull/23) [`d2d1eca`](https://github.com/Semantu/linked/commit/d2d1eca3517af11f39348dc83ba5e60703ef86d2) Thanks [@flyon](https://github.com/flyon)! - ## Breaking Changes
 
-  **New:** `getQueryDispatch()` and `setQueryDispatch()` are now exported, allowing custom query dispatch implementations (e.g. for testing or alternative storage backends) without subclassing `LinkedStorage`.
+  ### `Shape.select()` and `Shape.update()` no longer accept an ID as the first argument
 
-## 1.2.1
+  Use `.for(id)` to target a specific entity instead.
 
-### Patch Changes
+  **Select:**
 
-- [#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.
+  ```typescript
+  // Before
+  const result = await Person.select({ id: "..." }, (p) => p.name);
 
-  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).
+  // After
+  const result = await Person.select((p) => p.name).for({ id: "..." });
+  ```
 
-  Also adds regression coverage for desugar preservation, IR lowering completeness, and updated SPARQL golden output for nested query fixtures.
+  `.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:
 
-## 1.2.0
+  ```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).
 
 ### 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`.
+
 - [#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.
@@ -78,6 +173,14 @@
 
   See [SPARQL Algebra Layer docs](./documentation/sparql-algebra.md) for the full type reference, conversion rules, and store implementation guide.
 
+### Patch Changes
+
+- [#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.
+
+  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.1.0
 
 ### Minor Changes

package/README.md

@@ -7,6 +7,7 @@ Linked core gives you a type-safe, schema-parameterized query language and SHACL
 
 - **Schema-Parameterized Query DSL**: TypeScript-embedded queries driven by your Shape definitions.
 - **Fully Inferred Result Types**: The TypeScript return type of every query is automatically inferred from the selected paths — no manual type annotations needed. Select `p.name` and get `{id: string; name: string}[]`. Select `p.friends.name` and get nested result types. This works for all operations: select, create, update, and delete.
+- **Dynamic Query Building**: Build queries programmatically with `QueryBuilder`, compose field selections with `FieldSet`, and serialize/deserialize queries as JSON — for CMS dashboards, dynamic forms, and API-driven query construction.
 - **Shape Classes (SHACL)**: TypeScript classes that generate SHACL shape metadata.
 - **Object-Oriented Data Operations**: Query, create, update, and delete data using the same Shape-based API.
 - **Storage Routing**: `LinkedStorage` routes query objects to your configured store(s) that implement `IQuadStore`.
@@ -245,10 +246,9 @@ const allFriends = await Person.select((p) => p.knows.selectAll());
 
 **3) Apply a simple mutation**
 ```typescript
-const myNode = {id: 'https://my.app/node1'};
-const updated = await Person.update(myNode, {
+const updated = await Person.update({
   name: 'Alicia',
-});
+}).for({id: 'https://my.app/node1'});
 /* updated: {id: string} & UpdatePartial<Person> */
 ```
 
@@ -295,6 +295,10 @@ The query DSL is schema-parameterized: you define your own SHACL shapes, and Lin
 - Query context variables
 - Preloading (`preloadFor`) for component-like queries
 - Create / Update / Delete mutations
+- Dynamic query building with `QueryBuilder`
+- Composable field sets with `FieldSet`
+- Mutation builders (`CreateBuilder`, `UpdateBuilder`, `DeleteBuilder`)
+- Query and FieldSet JSON serialization / deserialization
 
 ### Query examples
 
@@ -317,10 +321,9 @@ const flags = await Person.select((p) => p.isRealPerson);
 
 #### Target a specific subject
 ```typescript
-const myNode = {id: 'https://my.app/node1'};
-/* Result: {id: string; name: string} | null */
-const one = await Person.select(myNode, (p) => p.name);
-const missing = await Person.select({id: 'https://my.app/missing'}, (p) => p.name); // null
+/* Result: {id: string; name: string} */
+const one = await Person.select((p) => p.name).for({id: 'https://my.app/node1'});
+const missing = await Person.select((p) => p.name).for({id: 'https://my.app/missing'}); // null
 ```
 
 #### Multiple paths + nested paths
@@ -444,10 +447,10 @@ Where UpdatePartial<Shape> reflects the created properties.
 
 #### Update
 
-Update will patch any property that you send as payload and leave the rest untouched.
+Update will patch any property that you send as payload and leave the rest untouched. Chain `.for(id)` to target the entity:
 ```typescript
 /* Result: {id: string} & UpdatePartial<Person> */
-const updated = await Person.update({id: 'https://my.app/node1'}, {name: 'Alicia'});
+const updated = await Person.update({name: 'Alicia'}).for({id: 'https://my.app/node1'});
 ```
 Returns:
 ```json
@@ -463,9 +466,9 @@ When updating a property that holds multiple values (one that returns an array i
 To overwrite all values:
 ```typescript
 // Overwrite the full set of "knows" values.
-const overwriteFriends = await Person.update({id: 'https://my.app/person1'}, {
+const overwriteFriends = await Person.update({
   knows: [{id: 'https://my.app/person2'}],
-});
+}).for({id: 'https://my.app/person1'});
 ```
 The result will contain an object with `updatedTo`, to indicate that previous values were overwritten to this new set of values:
 ```json
@@ -475,17 +478,17 @@ The result will contain an object with `updatedTo`, to indicate that previous va
     updatedTo: [{id:"https://my.app/person2"}],
   }
 }
-``` 
+```
 
 To make incremental changes to the current set of values you can provide an object with `add` and/or `remove` keys:
 ```typescript
 // Add one value and remove one value without replacing the whole set.
-const addRemoveFriends = await Person.update({id: 'https://my.app/person1'}, {
+const addRemoveFriends = await Person.update({
   knows: {
     add: [{id: 'https://my.app/person2'}],
     remove: [{id: 'https://my.app/person3'}],
   },
-});
+}).for({id: 'https://my.app/person1'});
 ```
 This returns an object with the added and removed items
 ```json
@@ -559,6 +562,198 @@ Override behavior:
 - If an override omits `minCount`, `maxCount`, or `nodeKind`, inherited values are kept.
 - Current scope: compatibility checks for `datatype`, `class`, and `pattern` are not enforced yet.
 
+## Dynamic Query Building
+
+The DSL (`Person.select(...)`) is ideal when you know shapes at compile time. For apps that need to build queries at runtime — CMS dashboards, configurable reports, API endpoints that accept field selections — use `QueryBuilder` and `FieldSet`.
+
+### QueryBuilder
+
+`QueryBuilder` provides a fluent, chainable API for constructing queries programmatically. It accepts a Shape class or a shape IRI string.
+
+```typescript
+import {QueryBuilder} from '@_linked/core';
+
+// From a Shape class
+const query = QueryBuilder.from(Person)
+  .select(p => [p.name, p.knows])
+  .where(p => p.name.equals('Semmy'))
+  .limit(10);
+
+// From a shape IRI string (when the Shape class isn't available at compile time)
+const query = QueryBuilder.from('https://schema.org/Person')
+  .select(['name', 'knows'])
+  .where(p => p.name.equals('Semmy'));
+
+// QueryBuilder is PromiseLike — await it directly
+const results = await query;
+
+// Or inspect the compiled IR without executing
+const ir = query.build();
+```
+
+**Target specific entities:**
+```typescript
+// Single entity — result is unwrapped (not an array)
+const person = await QueryBuilder.from(Person)
+  .for({id: 'https://my.app/person1'})
+  .select(p => p.name);
+
+// Multiple entities
+const people = await QueryBuilder.from(Person)
+  .forAll([{id: 'https://my.app/p1'}, {id: 'https://my.app/p2'}])
+  .select(p => p.name);
+```
+
+**Sorting, limiting, and single results:**
+```typescript
+const topFive = await QueryBuilder.from(Person)
+  .select(p => p.name)
+  .orderBy(p => p.name, 'ASC')
+  .limit(5);
+
+const first = await QueryBuilder.from(Person)
+  .select(p => p.name)
+  .one();
+```
+
+**Select with a FieldSet:**
+```typescript
+const fields = FieldSet.for(Person, ['name', 'knows']);
+const results = await QueryBuilder.from(Person).select(fields);
+```
+
+### FieldSet — composable field selections
+
+`FieldSet` is an independent, reusable object that describes which fields to select from a shape. Create them, compose them, and feed them into queries.
+
+**Creating a FieldSet:**
+```typescript
+import {FieldSet} from '@_linked/core';
+
+// From a Shape class with string field names
+const fs = FieldSet.for(Person, ['name', 'knows']);
+
+// From a Shape class with a type-safe callback
+const fs = FieldSet.for(Person, p => [p.name, p.knows]);
+
+// From a shape IRI string (when you only have the shape's IRI)
+const fs = FieldSet.for('https://schema.org/Person', ['name', 'knows']);
+
+// Select all decorated properties
+const allFields = FieldSet.all(Person);
+
+// Select all properties with depth (includes nested shapes)
+const deep = FieldSet.all(Person, {depth: 2});
+```
+
+**Nested fields:**
+```typescript
+// Dot-separated paths for nested properties
+const fs = FieldSet.for(Person, ['name', 'knows.name']);
+
+// Object form for nested sub-selections
+const fs = FieldSet.for(Person, [{knows: ['name', 'hobby']}]);
+```
+
+**Composing FieldSets:**
+```typescript
+const base = FieldSet.for(Person, ['name']);
+
+// Add fields
+const extended = base.add(['knows', 'birthDate']);
+
+// Remove fields
+const minimal = extended.remove(['birthDate']);
+
+// Pick specific fields
+const picked = extended.pick(['name', 'knows']);
+
+// Merge multiple FieldSets
+const merged = FieldSet.merge([fieldSet1, fieldSet2]);
+```
+
+**Inspecting a FieldSet:**
+```typescript
+const fs = FieldSet.for(Person, ['name', 'knows']);
+fs.labels();  // ['name', 'knows']
+fs.paths();   // [PropertyPath, PropertyPath]
+```
+
+**Use cases:**
+
+```typescript
+// Dynamically selected fields from a UI
+const fields = FieldSet.for(Person, userSelectedFields);
+const results = await QueryBuilder.from(Person).select(fields);
+
+// API gateway: accept fields as query parameters
+const fields = FieldSet.for(Person, req.query.fields.split(','));
+const results = await QueryBuilder.from(Person).select(fields);
+
+// Component composition: merge field sets from child components
+const merged = FieldSet.merge([headerFields, sidebarFields, contentFields]);
+const results = await QueryBuilder.from(Person).select(merged);
+
+// Progressive loading: start minimal, add detail on demand
+const summary = FieldSet.for(Person, ['name']);
+const detail = summary.add(['email', 'knows', 'birthDate']);
+```
+
+### Mutation Builders
+
+The mutation builders are the programmatic equivalent of `Person.create(...)`, `Person.update(...)`, and `Person.delete(...)`. They accept Shape classes or shape IRI strings.
+
+```typescript
+import {CreateBuilder, UpdateBuilder, DeleteBuilder} from '@_linked/core';
+
+// Create — equivalent to Person.create({name: 'Alice'})
+const created = await CreateBuilder.from(Person)
+  .set({name: 'Alice'})
+  .withId('https://my.app/alice');
+
+// Update — equivalent to Person.update({name: 'Alicia'}).for({id: '...'})
+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'});
+
+// All builders are PromiseLike — await them or call .build() for the IR
+const ir = CreateBuilder.from(Person).set({name: 'Alice'}).build();
+```
+
+### JSON Serialization
+
+Queries and FieldSets can be serialized to JSON and reconstructed — useful for saving query configurations, sending them over the wire, or building query editor UIs.
+
+```typescript
+// Serialize a QueryBuilder
+const query = QueryBuilder.from(Person)
+  .select(p => [p.name, p.knows])
+  .where(p => p.name.equals('Semmy'));
+
+const json = query.toJSON();
+// json is a plain object — store it, send it, etc.
+
+// Reconstruct from JSON
+const restored = QueryBuilder.fromJSON(json);
+const results = await restored;
+
+// FieldSet serialization works the same way
+const fs = FieldSet.for(Person, ['name', 'knows']);
+const fsJson = fs.toJSON();
+const restoredFs = FieldSet.fromJSON(fsJson);
+```
+
+Example JSON output for `QueryBuilder.from(Person).select(p => p.name).toJSON()`:
+```json
+{
+  "shape": "https://schema.org/Person",
+  "fields": [{"path": "name"}]
+}
+```
+
 ## TODO
 
 - Allow `preloadFor` to accept another query (not just a component).

package/lib/cjs/index.d.ts

@@ -1,3 +1,11 @@
-import nextTick from 'next-tick';
-export { nextTick };
+export { QueryBuilder } from './queries/QueryBuilder.js';
+export { PropertyPath, walkPropertyPath } from './queries/PropertyPath.js';
+export type { WhereCondition, WhereOperator } from './queries/WhereCondition.js';
+export { FieldSet } from './queries/FieldSet.js';
+export type { FieldSetEntry, FieldSetInput, FieldSetJSON, FieldSetFieldJSON } from './queries/FieldSet.js';
+export type { QueryBuilderJSON } from './queries/QueryBuilder.js';
+export { CreateBuilder } from './queries/CreateBuilder.js';
+export { UpdateBuilder } from './queries/UpdateBuilder.js';
+export { DeleteBuilder } from './queries/DeleteBuilder.js';
+export type { LinkedComponentInterface, QueryComponentLike } from './queries/SelectQuery.js';
 export declare function initModularApp(): void;

package/lib/cjs/index.js

@@ -32,11 +32,8 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nextTick = void 0;
+exports.DeleteBuilder = exports.UpdateBuilder = exports.CreateBuilder = exports.FieldSet = exports.walkPropertyPath = exports.PropertyPath = exports.QueryBuilder = void 0;
 exports.initModularApp = initModularApp;
 /*
  * This Source Code Form is subject to the terms of the Mozilla Public
@@ -77,8 +74,29 @@ const lincd = __importStar(require("./ontologies/lincd.js"));
 const owl = __importStar(require("./ontologies/owl.js"));
 const npm = __importStar(require("./ontologies/npm.js"));
 const Sparql = __importStar(require("./sparql/index.js"));
-const next_tick_1 = __importDefault(require("next-tick"));
-exports.nextTick = next_tick_1.default;
+const QueryBuilderModule = __importStar(require("./queries/QueryBuilder.js"));
+const PropertyPathModule = __importStar(require("./queries/PropertyPath.js"));
+const WhereConditionModule = __importStar(require("./queries/WhereCondition.js"));
+const FieldSetModule = __importStar(require("./queries/FieldSet.js"));
+const CreateBuilderModule = __importStar(require("./queries/CreateBuilder.js"));
+const UpdateBuilderModule = __importStar(require("./queries/UpdateBuilder.js"));
+const DeleteBuilderModule = __importStar(require("./queries/DeleteBuilder.js"));
+// New dynamic query building API (Phase 2)
+var QueryBuilder_js_1 = require("./queries/QueryBuilder.js");
+Object.defineProperty(exports, "QueryBuilder", { enumerable: true, get: function () { return QueryBuilder_js_1.QueryBuilder; } });
+var PropertyPath_js_1 = require("./queries/PropertyPath.js");
+Object.defineProperty(exports, "PropertyPath", { enumerable: true, get: function () { return PropertyPath_js_1.PropertyPath; } });
+Object.defineProperty(exports, "walkPropertyPath", { enumerable: true, get: function () { return PropertyPath_js_1.walkPropertyPath; } });
+// Phase 3a — FieldSet
+var FieldSet_js_1 = require("./queries/FieldSet.js");
+Object.defineProperty(exports, "FieldSet", { enumerable: true, get: function () { return FieldSet_js_1.FieldSet; } });
+// Phase 3b — Mutation builders
+var CreateBuilder_js_1 = require("./queries/CreateBuilder.js");
+Object.defineProperty(exports, "CreateBuilder", { enumerable: true, get: function () { return CreateBuilder_js_1.CreateBuilder; } });
+var UpdateBuilder_js_1 = require("./queries/UpdateBuilder.js");
+Object.defineProperty(exports, "UpdateBuilder", { enumerable: true, get: function () { return UpdateBuilder_js_1.UpdateBuilder; } });
+var DeleteBuilder_js_1 = require("./queries/DeleteBuilder.js");
+Object.defineProperty(exports, "DeleteBuilder", { enumerable: true, get: function () { return DeleteBuilder_js_1.DeleteBuilder; } });
 function initModularApp() {
     let publicFiles = {
         Package,
@@ -115,6 +133,13 @@ function initModularApp() {
         owl,
         npm,
         Sparql,
+        QueryBuilderModule,
+        PropertyPathModule,
+        WhereConditionModule,
+        FieldSetModule,
+        CreateBuilderModule,
+        UpdateBuilderModule,
+        DeleteBuilderModule,
     };
     var lincdExport = {};
     for (let fileKey in publicFiles) {

package/lib/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,wCAiDC;AA3FD;;;;GAIG;AACH,4DAA8C;AAC9C,kFAAoE;AACpE,gFAAkE;AAClE,wEAA0D;AAC1D,kEAAoD;AACpD,kEAAoD;AACpD,yDAA2C;AAC3C,+DAAiD;AACjD,oEAAsD;AACtD,0DAA4C;AAC5C,oDAAsC;AACtC,sEAAwD;AACxD,sEAAwD;AACxD,0EAA4D;AAC5D,sEAAwD;AACxD,sEAAwD;AACxD,0EAA4D;AAC5D,wEAA0D;AAC1D,oGAAsF;AACtF,gEAAkD;AAClD,kEAAoD;AACpD,0DAA4C;AAC5C,uDAAyC;AACzC,6EAA+D;AAC/D,uEAAyD;AACzD,uEAAyD;AACzD,yDAA2C;AAC3C,2DAA6C;AAC7C,yDAA2C;AAC3C,6DAA+C;AAC/C,6DAA+C;AAC/C,yDAA2C;AAC3C,yDAA2C;AAC3C,0DAA4C;AAC5C,0DAAiC;AACzB,mBADD,mBAAQ,CACC;AAEhB,SAAgB,cAAc;IAC5B,IAAI,WAAW,GAAG;QAChB,OAAO;QACP,kBAAkB;QAClB,iBAAiB;QACjB,aAAa;QACb,OAAO;QACP,OAAO;QACP,KAAK;QACL,QAAQ;QACR,MAAM;QACN,SAAS;QACT,MAAM;QACN,GAAG;QACH,UAAU;QACV,IAAI;QACJ,aAAa;QACb,UAAU;QACV,UAAU;QACV,WAAW;QACX,WAAW;QACX,aAAa;QACb,WAAW;QACX,WAAW;QACX,aAAa;QACb,YAAY;QACZ,0BAA0B;QAC1B,WAAW;QACX,GAAG;QACH,IAAI;QACJ,GAAG;QACH,KAAK;QACL,KAAK;QACL,GAAG;QACH,GAAG;QACH,MAAM;KACP,CAAC;IACF,IAAI,WAAW,GAAG,EAAE,CAAC;IACrB,KAAK,IAAI,OAAO,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,eAAe,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;QAC3C,KAAK,IAAI,SAAS,IAAI,eAAe,EAAE,CAAC;YACtC,WAAW,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QAClC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAC9C,CAAC;SAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAC9C,CAAC;AACH,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkEA,wCAwDC;AA1HD;;;;GAIG;AACH,4DAA8C;AAC9C,kFAAoE;AACpE,gFAAkE;AAClE,wEAA0D;AAC1D,kEAAoD;AACpD,kEAAoD;AACpD,yDAA2C;AAC3C,+DAAiD;AACjD,oEAAsD;AACtD,0DAA4C;AAC5C,oDAAsC;AACtC,sEAAwD;AACxD,sEAAwD;AACxD,0EAA4D;AAC5D,sEAAwD;AACxD,sEAAwD;AACxD,0EAA4D;AAC5D,wEAA0D;AAC1D,oGAAsF;AACtF,gEAAkD;AAClD,kEAAoD;AACpD,0DAA4C;AAC5C,uDAAyC;AACzC,6EAA+D;AAC/D,uEAAyD;AACzD,uEAAyD;AACzD,yDAA2C;AAC3C,2DAA6C;AAC7C,yDAA2C;AAC3C,6DAA+C;AAC/C,6DAA+C;AAC/C,yDAA2C;AAC3C,yDAA2C;AAC3C,0DAA4C;AAC5C,8EAAgE;AAChE,8EAAgE;AAChE,kFAAoE;AACpE,sEAAwD;AACxD,gFAAkE;AAClE,gFAAkE;AAClE,gFAAkE;AAClE,2CAA2C;AAC3C,6DAAuD;AAA/C,+GAAA,YAAY,OAAA;AACpB,6DAAyE;AAAjE,+GAAA,YAAY,OAAA;AAAE,mHAAA,gBAAgB,OAAA;AAGtC,sBAAsB;AACtB,qDAA+C;AAAvC,uGAAA,QAAQ,OAAA;AAMhB,+BAA+B;AAC/B,+DAAyD;AAAjD,iHAAA,aAAa,OAAA;AACrB,+DAAyD;AAAjD,iHAAA,aAAa,OAAA;AACrB,+DAAyD;AAAjD,iHAAA,aAAa,OAAA;AAKrB,SAAgB,cAAc;IAC5B,IAAI,WAAW,GAAG;QAChB,OAAO;QACP,kBAAkB;QAClB,iBAAiB;QACjB,aAAa;QACb,OAAO;QACP,OAAO;QACP,KAAK;QACL,QAAQ;QACR,MAAM;QACN,SAAS;QACT,MAAM;QACN,GAAG;QACH,UAAU;QACV,IAAI;QACJ,aAAa;QACb,UAAU;QACV,UAAU;QACV,WAAW;QACX,WAAW;QACX,aAAa;QACb,WAAW;QACX,WAAW;QACX,aAAa;QACb,YAAY;QACZ,0BAA0B;QAC1B,WAAW;QACX,GAAG;QACH,IAAI;QACJ,GAAG;QACH,KAAK;QACL,KAAK;QACL,GAAG;QACH,GAAG;QACH,MAAM;QACN,kBAAkB;QAClB,kBAAkB;QAClB,oBAAoB;QACpB,cAAc;QACd,mBAAmB;QACnB,mBAAmB;QACnB,mBAAmB;KACpB,CAAC;IACF,IAAI,WAAW,GAAG,EAAE,CAAC;IACrB,KAAK,IAAI,OAAO,IAAI,WAAW,EAAE,CAAC;QAChC,IAAI,eAAe,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;QAC3C,KAAK,IAAI,SAAS,IAAI,eAAe,EAAE,CAAC;YACtC,WAAW,CAAC,SAAS,CAAC,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;QACtD,CAAC;IACH,CAAC;IACD,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QAClC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAC9C,CAAC;SAAM,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE,CAAC;QACzC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC;IAC9C,CAAC;AACH,CAAC"}

package/lib/cjs/package.d.ts

@@ -1,4 +1,4 @@
 export declare const linkedShape: {
     <T extends typeof import("./shapes/Shape.js").Shape>(constructor: T): void;
     <T extends typeof import("./shapes/Shape.js").Shape>(config?: import("./utils/Package.js").ShapeConfig): (constructor: T) => void;
-}, linkedUtil: (constructor: any) => any, linkedOntology: (allFileExports: any, nameSpace: (term: string) => import("./utils/NodeReference.js").NodeReferenceValue, suggestedPrefixAndFileName: string, loadDataFunction?: () => Promise<any>, dataSource?: string | string[]) => void, registerPackageExport: (exportedObject: any) => void, registerPackageModule: (_module: any) => void, packageExports: any, getPackageShape: (name: string) => typeof import("./shapes/Shape.js").Shape;
+}, linkedUtil: (constructor: any) => any, linkedOntology: (allFileExports: any, nameSpace: (term: string) => import("./utils/NodeReference.js").NodeReferenceValue, suggestedPrefixAndFileName: string, loadDataFunction?: () => Promise<any>, dataSource?: string | string[]) => void, registerPackageExport: (exportedObject: any) => void, registerPackageModule: (_module: any) => void, packageExports: any, getPackageShape: (name: string) => import("./shapes/Shape.js").ShapeConstructor | undefined;

package/lib/cjs/queries/CreateBuilder.d.ts

@@ -0,0 +1,38 @@
+import { Shape, ShapeConstructor } from '../shapes/Shape.js';
+import { UpdatePartial } from './QueryFactory.js';
+import { CreateQuery, CreateResponse } from './CreateQuery.js';
+/**
+ * An immutable, fluent builder for create mutations.
+ *
+ * Every mutation method returns a new CreateBuilder — the original is never modified.
+ *
+ * Implements PromiseLike so mutations execute on `await`:
+ * ```ts
+ * const result = await CreateBuilder.from(Person).set({name: 'Alice'});
+ * ```
+ *
+ * Internally delegates to CreateQueryFactory for IR generation.
+ */
+export declare class CreateBuilder<S extends Shape = Shape, U extends UpdatePartial<S> = UpdatePartial<S>> implements PromiseLike<CreateResponse<U>>, Promise<CreateResponse<U>> {
+    private readonly _shape;
+    private readonly _data?;
+    private readonly _fixedId?;
+    private constructor();
+    private clone;
+    /**
+     * Create a CreateBuilder for the given shape.
+     */
+    static from<S extends Shape>(shape: ShapeConstructor<S> | string): CreateBuilder<S>;
+    /** Set the data for the entity to create. */
+    set<NewU extends UpdatePartial<S>>(data: NewU): CreateBuilder<S, NewU>;
+    /** Pre-assign a node ID for the created entity. */
+    withId(id: string): CreateBuilder<S, U>;
+    /** Build the IR mutation. Throws if no data was set via .set(). */
+    build(): CreateQuery;
+    /** Execute the mutation. */
+    exec(): Promise<CreateResponse<U>>;
+    then<TResult1 = CreateResponse<U>, TResult2 = never>(onfulfilled?: ((value: CreateResponse<U>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<CreateResponse<U> | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<CreateResponse<U>>;
+    get [Symbol.toStringTag](): string;
+}