@coasys/ad4m / Exports / AutoProcessorConfig

Class: AutoProcessorConfig

Base class for defining data models in AD4M.

Description

Ad4mModel provides the foundation for creating data models that are stored in AD4M perspectives. Each model instance is represented as a subgraph in the perspective, with properties and relations mapped to links in that graph. The class uses Prolog-based queries to efficiently search and filter instances based on their properties and relationships.

Key concepts:

Each model instance has a unique base expression that serves as its identifier
Properties are stored as links with predicates defined by the through option
Relations represent one-to-many relationships as sets of links
Queries are translated to Prolog for efficient graph pattern matching
Changes are tracked through the perspective's subscription system

Example

// Define a recipe model
@Model({ name: "Recipe" })
class Recipe extends Ad4mModel {
  // Plain property — no `resolveLanguage` → deterministic typed literal
  // storage (fast POS-index path). This is the perf default.
  @Property({ through: "recipe://name" })
  name: string = "";
 
  // Property that needs per-value provenance (e.g. a signed message body):
  // `resolveLanguage: "literal"` routes values through expression_create on
  // the built-in literal language, producing a signed envelope URI
  // (author/timestamp/proof) instead of a bare typed literal.
  @Property({
    through: "recipe://signed_note",
    resolveLanguage: "literal"
  })
  signedNote: string = "";
 
  // Property resolved through a custom language: values are routed through
  // expression_create on that language (signed expression URIs).
  @Optional({
    through: "recipe://photo",
    resolveLanguage: "QmFileStorageLanguageAddress..."
  })
  photo: string = "";
 
  // Optional property with custom initial value
  @Optional({
    through: "recipe://status",
    initial: "recipe://draft"
  })
  status: string = "";
 
  // Read-only computed property
  @ReadOnly({
    through: "recipe://rating",
    getter: `
      findall(Rating, triple(Base, "recipe://user_rating", Rating), Ratings),
      sum_list(Ratings, Sum),
      length(Ratings, Count),
      Value is Sum / Count
    `
  })
  averageRating: number = 0;
 
  // Relation of ingredients
  *   @HasMany({ through: "recipe://ingredient" })
  *   ingredients: string[] = [];
 
  // Relation of comments linked to another model
  @HasMany(() => Comment, { through: "recipe://comment" })
  comments: Comment[] = [];
}
 
// Create and save a new recipe
const recipe = new Recipe(perspective);
recipe.name = "Chocolate Cake";
recipe.ingredients = ["flour", "sugar", "cocoa"];
await recipe.save();
 
// Query recipes in different ways
// Get all recipes
const allRecipes = await Recipe.findAll(perspective);
 
// Find recipes with specific criteria
const desserts = await Recipe.findAll(perspective, {
  where: { 
    status: "recipe://published",
    averageRating: { gt: 4 }
  },
  order: { name: "ASC" },
  limit: 10
});
 
// Use the fluent query builder
const popularRecipes = await Recipe.query(perspective)
  .where({ averageRating: { gt: 4.5 } })
  .order({ averageRating: "DESC" })
  .limit(5)
  .get();
 
// Subscribe to real-time updates
await Recipe.query(perspective)
  .where({ status: "recipe://cooking" })
  .subscribe(recipes => {
    console.log("Currently being cooked:", recipes);
  });
 
// Paginate results
const { results, totalCount, pageNumber } = await Recipe.query(perspective)
  .where({ status: "recipe://published" })
  .paginate(10, 1);

Hierarchy

Ad4mModel

↳ AutoProcessorConfig

Constructors

constructor

Properties

Accessors

Methods

Constructors

constructor

• new AutoProcessorConfig(perspective, baseExpression?)

Constructs a new model instance.

Parameters

Name	Type	Description
`perspective`	`PerspectiveProxy`	The perspective where this model will be stored
`baseExpression?`	`string`	Optional expression URI for this instance. If omitted, a random `ad4m://obj/<id>` IRI is generated, independent of any property content — this is what keeps two instances with identical property values distinct.

Example

// Create a new recipe with auto-generated base expression
const recipe = new Recipe(perspective);
 
// Create with specific base expression
const recipe = new Recipe(perspective, "ad4m://obj/existing-id");

Inherited from

Ad4mModel.constructor

Defined in

core/src/model/Ad4mModel.ts:721 (opens in a new tab)

Properties

__links

• Optional __links: LinksMap

Per-link rows for the entries asked for with Query.links, keyed as they were asked. Absent when the query did not ask for any.

Inherited from

Ad4mModel.__links

Defined in

core/src/model/Ad4mModel.ts:499 (opens in a new tab)

author

• author: string

Inherited from

Ad4mModel.author

Defined in

core/src/model/Ad4mModel.ts:492 (opens in a new tab)

basePrefix

• Optional basePrefix: string

URI prefix for minted instances; omit for the per-processor default.

Defined in

core/src/perspectives/InterpretationModels.ts:53 (opens in a new tab)

batchMax

• batchMax: string = "32"

Maximum items per pass.

Defined in

core/src/perspectives/InterpretationModels.ts:73 (opens in a new tab)

batchMin

• Optional batchMin: string

Minimum batch size before a pass runs (default 1).

Defined in

core/src/perspectives/InterpretationModels.ts:69 (opens in a new tab)

claimTtlMs

• claimTtlMs: string = "60000"

How long a won claim is authoritative before peers may re-claim (ms).

Defined in

core/src/perspectives/InterpretationModels.ts:81 (opens in a new tab)

createdAt

• createdAt: any

Inherited from

Ad4mModel.createdAt

Defined in

core/src/model/Ad4mModel.ts:493 (opens in a new tab)

debounceMs

• debounceMs: string = "200"

Quiet-window (ms) after the last new item before a pass runs.

Defined in

core/src/perspectives/InterpretationModels.ts:65 (opens in a new tab)

dedupStrategy

• Optional dedupStrategy: string

Serialised DedupStrategy JSON (absent = NormalizedString).

Defined in

core/src/perspectives/InterpretationModels.ts:89 (opens in a new tab)

emitDebugEvents

• Optional emitDebugEvents: string

Enable full debug observability: persists the raw LLM prompt + response on the pass's InterpretationRun AND emits LlmRequestSent / LlmResponseReceived mid-pass events. "true" / "false" string.

Defined in

core/src/perspectives/InterpretationModels.ts:130 (opens in a new tab)

existingScope

• Optional existingScope: string

Serialised Scope JSON (absent = whole-perspective dedup set). Constrains the existing-instance lookup to the subtree rooted at Scope.id linked via Scope.predicate — the SoA-tree "existing items live under THIS project node" pattern. Stored as an opaque JSON blob because SHACL properties carry no rich-object type-check; the Rust watcher parses it back into Scope.

Defined in

core/src/perspectives/InterpretationModels.ts:100 (opens in a new tab)

flows

• flows: string[] = []

Flow URIs ({namespace}{name}Flow) this processor runs flow features on; empty = off.

Defined in

core/src/perspectives/InterpretationModels.ts:61 (opens in a new tab)

interpretationClasses

• interpretationClasses: string[] = []

Class URIs (SHACL targetClass) to materialise each pass.

Defined in

core/src/perspectives/InterpretationModels.ts:57 (opens in a new tab)

maxToolCalls

• Optional maxToolCalls: string

Tool-call budget for the interpretation-pass harness. Absent (or "0") = the original single-shot LLM path — one prompt, one parse, no tools. "N" (positive integer) = engage the tool-calling harness and let the LLM issue up to N tool calls per pass (query/list/get/propose_create/ propose_link_child) before being forced to answer. Stored as a decimal string because SHACL properties carry no numeric type; the Rust watcher parses it back to u32.

Defined in

core/src/perspectives/InterpretationModels.ts:122 (opens in a new tab)

maxWaitMs

• Optional maxWaitMs: string

Safety flush (ms) for a sub-batchMin batch; absent = wait indefinitely.

Defined in

core/src/perspectives/InterpretationModels.ts:77 (opens in a new tab)

mintScope

• Optional mintScope: string

Serialised Scope JSON (absent = mint sites are unlinked). When set, every freshly created base URI gets an additional Scope.id --Scope.predicate--> new-uri link written into the perspective, so mints become first-class children of the target scope. Must be the Raw form of Scope; Model scopes carry no linking predicate.

Defined in

core/src/perspectives/InterpretationModels.ts:110 (opens in a new tab)

processorId

• processorId: string = ""

Unique processor id — the dedup key for auto-processor instances.

Defined in

core/src/perspectives/InterpretationModels.ts:41 (opens in a new tab)

sourceScopeQuery

• sourceScopeQuery: string = ""

SPARQL SELECT that gathers source items each pass.

Defined in

core/src/perspectives/InterpretationModels.ts:45 (opens in a new tab)

sourceWindowMs

• Optional sourceWindowMs: string

How far back (ms) each pass looks; absent = unbounded.

Defined in

core/src/perspectives/InterpretationModels.ts:85 (opens in a new tab)

updatedAt

• updatedAt: any

Inherited from

Ad4mModel.updatedAt

Defined in

core/src/model/Ad4mModel.ts:494 (opens in a new tab)

Accessors

id

• get id(): string

The unique identifier (expression URI) of this model instance.

Returns

string

Inherited from

Ad4mModel.id

Defined in

core/src/model/Ad4mModel.ts:738 (opens in a new tab)

perspective

• Protected get perspective(): PerspectiveProxy

Protected getter for the perspective. Allows subclasses to access the perspective while keeping it private from external code.

Returns

PerspectiveProxy

Inherited from

Ad4mModel.perspective

Defined in

core/src/model/Ad4mModel.ts:746 (opens in a new tab)

timestamp

• get timestamp(): any

Backwards compatibility alias for createdAt.

Returns

any

Deprecated

Use createdAt instead. This will be removed in a future version.

Inherited from

Ad4mModel.timestamp

Defined in

core/src/model/Ad4mModel.ts:505 (opens in a new tab)

Methods

changedFields

▸ changedFields(): string[]

Returns the names of properties/relations that differ from the snapshot taken at the last hydration.

Returns all field names if no snapshot exists.

Returns

string[]

Example

recipe.name = "New Name";
recipe.changedFields(); // ["name"]

Inherited from

Ad4mModel.changedFields

Defined in

core/src/model/Ad4mModel.ts:927 (opens in a new tab)

delete

▸ delete(batchId?): Promise<void>

Deletes the model instance from the perspective.

Parameters

Name	Type	Description
`batchId?`	`string`	Optional batch ID for batch operations

Returns

Promise<void>

Throws

Will throw if removal fails

Example

const recipe = await Recipe.findAll(perspective)[0];
await recipe.delete();
 
// Or with batch operations:
const batchId = await perspective.createBatch();
await recipe.delete(batchId);
await perspective.commitBatch(batchId);

Inherited from

Ad4mModel.delete

Defined in

core/src/model/Ad4mModel.ts:1870 (opens in a new tab)

get

▸ get(optsOrInclude?): Promise<AutoProcessorConfig>

Gets the model instance with all properties and relations populated.

Parameters

Name	Type	Description
`optsOrInclude?`	`IncludeMap` \| `GetOptions`	Optional hydration options. Accepts two forms: - `GetOptions` wrapper: `{ include: { comments: true }, properties: ['title'] }` - `IncludeMap` shorthand: `{ comments: true }` (equivalent to `{ include: { comments: true } }`)

Returns

Promise<AutoProcessorConfig>

The populated model instance

Throws

Will throw if data retrieval fails

Example

const recipe = new Recipe(perspective, existingId);
await recipe.get();
console.log(recipe.name, recipe.ingredients);
 
// Shorthand — pass IncludeMap directly:
await recipe.get({ ingredients: true });
 
// Full options — includes sparse fieldset:
await recipe.get({ include: { ingredients: true }, properties: ['name'] });

Inherited from

Ad4mModel.get

Defined in

core/src/model/Ad4mModel.ts:1838 (opens in a new tab)

isDirty

▸ isDirty(): boolean

Returns true if any tracked property or relation has changed since the last hydration (or since takeSnapshot() was last called).

Always returns true if no snapshot exists (e.g. a freshly constructed instance that hasn't been fetched yet).

Returns

boolean

Example

const recipe = await Recipe.create(perspective, { name: "Pasta" });
recipe.isDirty();        // false — just hydrated
recipe.name = "Risotto";
recipe.isDirty();        // true

Inherited from

Ad4mModel.isDirty

Defined in

core/src/model/Ad4mModel.ts:910 (opens in a new tab)

save

▸ save(batchId?): Promise<void>

Saves the model instance to the perspective.

New instances (no snapshot yet): creates the subject via createSubject with initial scalar values, then sets relations via innerUpdate.

Existing instances (snapshot present, i.e. fetched via get() or a query): updates only dirty fields via innerUpdate, then refreshes from the perspective.

Parameters

Name	Type	Description
`batchId?`	`string`	Optional batch ID for batch operations

Returns

Promise<void>

Throws

Will throw if instance creation, linking, or updating fails

Example

// Create
const recipe = new Recipe(perspective);
recipe.name = "Spaghetti";
await recipe.save();
 
// Update
recipe.rating = 10;
await recipe.save();

Inherited from

Ad4mModel.save

Defined in

core/src/model/Ad4mModel.ts:1528 (opens in a new tab)

count

▸ Static count<T>(this, perspective, query?, options?): Promise<number>

Gets a count of all matching instances.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to search in
`query?`	`TypedQuery`<`T`>	Optional query parameters to filter results
`options?`	`CallOptions`	-

Returns

Promise<number>

Total count of matching entities

Example

const totalRecipes = await Recipe.count(perspective);
const activeRecipes = await Recipe.count(perspective, {
  where: { status: "active" }
});

Inherited from

Ad4mModel.count

Defined in

core/src/model/Ad4mModel.ts:1384 (opens in a new tab)

create

▸ Static create<T>(this, perspective, data?, options?): Promise<T>

Creates and saves a new model instance in one step.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to create the instance in
`data`	`Record`<`string`, `any`>	Property values to assign before saving
`options?`	`Object`	Optional settings: - `parent` — a `Scope` (model form or raw form) whose `id` will be used to create an incoming link from the parent to the new instance. - `batchId` — an existing batch id; when provided the link write and `save()` are added to the batch instead of committed immediately.
`options.batchId?`	`string`	-
`options.parent?`	`Scope`	-

Returns

Promise<T>

The saved model instance

Example

// Simple create
const recipe = await Recipe.create(perspective, {
  name: "Spaghetti",
  rating: 5,
});
 
// Create under a parent (link auto-created)
const comment = await Comment.create(perspective, { text: "Great!" }, {
  parent: { model: Post, id: postId },
});
 
// Create inside a transaction
await Ad4mModel.transaction(perspective, async (tx) => {
  await Recipe.create(perspective, { name: "Pasta" }, { batchId: tx.batchId });
});

Inherited from

Ad4mModel.create

Defined in

core/src/model/Ad4mModel.ts:1960 (opens in a new tab)

delete

▸ Static delete(this, perspective, id): Promise<void>

Deletes an existing model instance identified by id.

Also cleans up any incoming links that point to this instance.

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `Ad4mModel`	-
`perspective`	`PerspectiveProxy`	The perspective containing the instance
`id`	`string`	The expression URI of the instance to delete

Returns

Promise<void>

Example

await Recipe.delete(perspective, recipeId);

Inherited from

Ad4mModel.delete

Defined in

core/src/model/Ad4mModel.ts:2075 (opens in a new tab)

evaluateGetters

▸ Static evaluateGetters<T>(instances, perspective, propertyNames?): Promise<void>

Evaluate SPARQL getters for a batch of instances on demand.

Since deepQuery defaults to true, property getters are evaluated automatically during collection queries. Use this method when deepQuery was explicitly set to false and you want to lazily resolve getter-backed properties for a subset of instances.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>

Parameters

Name	Type	Description
`instances`	`T`[]	Array of model instances to evaluate getters on
`perspective`	`PerspectiveProxy`	The perspective to query against
`propertyNames?`	`string`[]	Optional list of getter-backed property names to evaluate. If omitted, all getters are evaluated.

Returns

Promise<void>

Example

const messages = await Message.query(perspective).deepQuery(false).limit(30).get();
// messages[i].replyingTo is undefined (getter skipped)
 
// Evaluate getters for the visible subset
await Message.evaluateGetters(messages.slice(0, 10), perspective, ['replyingTo']);
// messages[0..9].replyingTo is now populated

Inherited from

Ad4mModel.evaluateGetters

Defined in

core/src/model/Ad4mModel.ts:1760 (opens in a new tab)

findAll

▸ Static findAll<T, Q>(this, perspective, query?, options?): Promise<T & IncludeExtras<T, IncludeOf<Q>>[]>

Gets all instances of the model in the perspective that match the query params.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>
`Q`	extends `Query` \| `StrictTypedQuery`<`T`> = {}

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to search in
`query?`	`Q`	Optional query parameters to filter results
`options?`	`CallOptions`	-

Returns

Promise<T & IncludeExtras<T, IncludeOf<Q>>[]>

Array of matching models

Example

const allRecipes = await Recipe.findAll(perspective);
 
const recipes = await Recipe.findAll(perspective, {
  where: {
    name: "Pasta",
    rating: { gt: 4 }
  },
  order: { createdAt: "DESC" },
  limit: 10
});

Inherited from

Ad4mModel.findAll

Defined in

core/src/model/Ad4mModel.ts:1255 (opens in a new tab)

findAllAndCount

▸ Static findAllAndCount<T, Q>(this, perspective, query?, options?): Promise<ResultsWithTotalCount<T & IncludeExtras<T, IncludeOf<Q>>>>

Gets all instances with count of total matches without offset & limit applied.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>
`Q`	extends `Query` \| `StrictTypedQuery`<`T`> = {}

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to search in
`query?`	`Q`	Optional query parameters to filter results
`options?`	`CallOptions`	-

Returns

Promise<ResultsWithTotalCount<T & IncludeExtras<T, IncludeOf<Q>>>>

Object containing results array and total count

Example

const { results, totalCount } = await Recipe.findAllAndCount(perspective, {
  where: { category: "Dessert" },
  limit: 10
});
console.log(`Showing 10 of ${totalCount} dessert recipes`);

Inherited from

Ad4mModel.findAllAndCount

Defined in

core/src/model/Ad4mModel.ts:1318 (opens in a new tab)

findOne

▸ Static findOne<T, Q>(this, perspective, query?, options?): Promise<T & IncludeExtras<T, IncludeOf<Q>>>

Finds the first instance matching the query, or null if none exists.

Equivalent to findAll with limit: 1 — only one instance is hydrated.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>
`Q`	extends `Query` \| `StrictTypedQuery`<`T`> = {}

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to search in
`query?`	`Q`	Optional query parameters to filter results
`options?`	`CallOptions`	-

Returns

Promise<T & IncludeExtras<T, IncludeOf<Q>>>

The first matching instance, or null

Example

const recipe = await Recipe.findOne(perspective, {
  where: { name: "Pasta" }
});
if (recipe) {
  console.log(recipe.name);
}

Inherited from

Ad4mModel.findOne

Defined in

core/src/model/Ad4mModel.ts:1290 (opens in a new tab)

fromJSONSchema

▸ Static fromJSONSchema(schema, options): typeof Ad4mModel

Creates an Ad4mModel class from a JSON Schema definition.

Parameters

Name	Type	Description
`schema`	`JSONSchema`	JSON Schema definition
`options`	`JSONSchemaToModelOptions`	Configuration options

Returns

typeof Ad4mModel

Generated Ad4mModel subclass

Description

This method dynamically generates an Ad4mModel subclass from a JSON Schema, enabling integration with systems that use JSON Schema for type definitions.

The method follows a cascading approach for determining predicates:

Explicit configuration in options parameter (highest precedence)
x-ad4m metadata in the JSON Schema
Inference from schema title and property names
Error if no namespace can be determined

Example

// With explicit configuration
const PersonClass = Ad4mModel.fromJSONSchema(schema, {
  name: "Person",
  namespace: "person://"
});
 
// With property mapping
const ContactClass = Ad4mModel.fromJSONSchema(schema, {
  name: "Contact",
  namespace: "contact://",
  propertyMapping: {
    "name": "foaf://name",
    "email": "foaf://mbox"
  }
});
 
// With x-ad4m metadata in schema
const schema = {
  "title": "Product",
  "x-ad4m": { "namespace": "product://" },
  "properties": {
    "name": { 
      "type": "string",
      "x-ad4m": { "through": "product://title" }
    }
  }
};
const ProductClass = Ad4mModel.fromJSONSchema(schema, { name: "Product" });

Throws

Error when namespace cannot be inferred

Inherited from

Ad4mModel.fromJSONSchema

Defined in

core/src/model/Ad4mModel.ts:2244 (opens in a new tab)

fromSHACL

▸ Static fromSHACL(shape, name, classResolver?): typeof Ad4mModel

Synthesise an Ad4mModel subclass from a SHACL shape.

Parameters

Name	Type	Description
`shape`	`SHACLShape`	The SHACL shape to synthesise from.
`name`	`string`	The model name (e.g. "Channel").
`classResolver?`	(`localName`: `string`) => typeof `Ad4mModel`	Optional thunk factory. When provided, any collection property that carries a `sh:class` URI will have its `target` wired up lazily: `target: () => classResolver(localName)`. Because `target` is only called at query time (inside `enrichShapeForIncludes` / `jsonToModelInstance`), the resolver just needs to return the correct class by the time a query runs — making it safe to pass a closure over a registry object that is still being populated (e.g. the `result` record inside `getModelClasses`).

generateSDNA

▸ Static generateSDNA(): Object

Generates the SDNA (Subject DNA) Prolog rules for this model class. Injected at class-definition time by the @Model decorator. Returns a default value on un-decorated base classes.

Returns

Object

Name	Type
`name`	`string`
`sdna`	`string`

Inherited from

Ad4mModel.generateSDNA

Defined in

core/src/model/Ad4mModel.ts:516 (opens in a new tab)

generateSHACL

▸ Static generateSHACL(): Object

Generates the SHACL shape graph for this model class. Injected at class-definition time by the @Model decorator. Returns { shape: null, name: '' } on un-decorated base classes — the decorator's parentSHACL?.shape?.nodeShapeUri check handles this.

Returns

Object

Name	Type
`name`	`string`
`shape`	`any`

Inherited from

Ad4mModel.generateSHACL

Defined in

core/src/model/Ad4mModel.ts:526 (opens in a new tab)

getClassName

▸ Static getClassName(perspective): Promise<string>

Parameters

Name	Type
`perspective`	`PerspectiveProxy`

Returns

Promise<string>

Inherited from

Ad4mModel.getClassName

Defined in

core/src/model/Ad4mModel.ts:530 (opens in a new tab)

getModelMetadata

▸ Static getModelMetadata(): ModelMetadata

Extracts metadata from decorators for query building.

Returns

ModelMetadata

Structured metadata object containing className, properties, and relations

Description

This method reads the metadata stored by decorators (@Property, @HasMany, etc.) and returns it in a structured format that's easier to work with for query builders and other systems that need to introspect model structure.

The metadata includes:

Class name from

Model

Property metadata (predicates, types, constraints, etc.)
Relation metadata (predicates, filters, etc.)

For models created via fromJSONSchema(), this method will derive metadata from the WeakMap registries that were populated during the dynamic class creation. If these structures are empty but a JSON schema was attached to the class, it can fall back to deriving metadata from that schema.

Throws

Error if the class doesn't have

Model

decorator

Example

@Model({ name: "Recipe" })
class Recipe extends Ad4mModel {
  @Property({ through: "recipe://name" })
  name: string = "";
 
  @HasMany({ through: "recipe://ingredient" })
  ingredients: string[] = [];
}
 
const metadata = Recipe.getModelMetadata();
console.log(metadata.className); // "Recipe"
console.log(metadata.properties.name.predicate); // "recipe://name"
console.log(metadata.relations.ingredients.predicate); // "recipe://ingredient"

Inherited from

Ad4mModel.getModelMetadata

Defined in

core/src/model/Ad4mModel.ts:593 (opens in a new tab)

paginate

▸ Static paginate<T, Q>(this, perspective, pageSize, pageNumber, query?, options?): Promise<PaginationResult<T & IncludeExtras<T, IncludeOf<Q>>>>

Helper function for pagination with explicit page size and number.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>
`Q`	extends `Query` \| `StrictTypedQuery`<`T`> = {}

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to search in
`pageSize`	`number`	Number of items per page
`pageNumber`	`number`	Which page to retrieve (1-based)
`query?`	`Q`	Optional additional query parameters
`options?`	`CallOptions`	-

Returns

Promise<PaginationResult<T & IncludeExtras<T, IncludeOf<Q>>>>

Paginated results with metadata

Example

const page = await Recipe.paginate(perspective, 10, 1, {
  where: { category: "Main Course" }
});
console.log(`Page ${page.pageNumber} of recipes, ${page.results.length} items`);

Inherited from

Ad4mModel.paginate

Defined in

core/src/model/Ad4mModel.ts:1345 (opens in a new tab)

query

▸ Static query<T>(this, perspective, query?): ModelQueryBuilder<T>

Creates a query builder for fluent query construction.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective to query
`query?`	`TypedQuery`<`T`>	Optional initial query parameters

Returns

ModelQueryBuilder<T>

A new query builder instance

Example

const recipes = await Recipe.query(perspective)
  .where({ category: "Dessert" })
  .order({ rating: "DESC" })
  .limit(5)
  .run();
 
// With real-time updates
await Recipe.query(perspective)
  .where({ status: "cooking" })
  .subscribe(recipes => {
    console.log("Currently cooking:", recipes);
  });

Inherited from

Ad4mModel.query

Defined in

core/src/model/Ad4mModel.ts:2186 (opens in a new tab)

queryToSPARQL

▸ Static queryToSPARQL(perspective, query): Promise<string>

Generates a SPARQL query from a Query object.

Parameters

Name	Type	Description
`perspective`	`PerspectiveProxy`	The perspective to query (used for metadata extraction)
`query`	`Query`	Query parameters (where, order, limit, offset, properties, relations)

Returns

Promise<string>

Complete SPARQL query string ready for execution

Description

This method translates high-level query parameters into a SPARQL query string that can be executed against the SPARQL backend. Unlike Prolog queries which operate on SDNA-aware predicates, SPARQL queries operate directly on raw links stored in SPARQL.

The generated query uses a CTE (Common Table Expression) pattern:

First, identify candidate base expressions by filtering links based on where conditions
Then, for each candidate base, resolve properties and relations via subqueries
Finally, apply ordering, pagination (LIMIT/START) at the SQL level

Key architectural notes:

SPARQL stores only raw links (source, predicate, target, author, timestamp)
No SDNA knowledge at the database level
Properties are resolved via subqueries that look for links with specific predicates
Relations are similar but return multiple values instead of one
Special fields (base, author, timestamp) are accessed directly, not via subqueries

Example

const query = Recipe.queryToSPARQL(perspective, {
  where: { name: "Pasta", rating: { gt: 4 } },
  order: { timestamp: "DESC" },
  limit: 10
});
// Returns: SELECT source AS base, array::first(target[WHERE predicate = ...]) AS name, ...
//          FROM link WHERE ... GROUP BY source ORDER BY timestamp DESC LIMIT 10

Inherited from

Ad4mModel.queryToSPARQL

Defined in

core/src/model/Ad4mModel.ts:1065 (opens in a new tab)

register

▸ Static register(this, perspective): Promise<void>

Registers this model's SHACL schema on the given perspective.

This ensures the perspective knows about the model's shape (properties, relations, constraints) so instances can be created, queried, and validated.

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel`	-
`perspective`	`PerspectiveProxy`	The perspective to register the model on

Returns

Promise<void>

Example

await Recipe.register(perspective);
// Now you can create / query Recipe instances on this perspective

Inherited from

Ad4mModel.register

Defined in

core/src/model/Ad4mModel.ts:2099 (opens in a new tab)

registerAll

▸ Static registerAll(perspective, models): Promise<void>

Batch-registers multiple model classes on a perspective in a single RPC call. This is significantly faster than calling register() on each model individually because it eliminates N-1 round-trips and mutex acquisitions.

Parameters

Name	Type	Description
`perspective`	`PerspectiveProxy`	The perspective to register the models on
`models`	typeof `Ad4mModel`[]	Array of Ad4mModel subclasses to register

Returns

Promise<void>

Example

await Ad4mModel.registerAll(perspective, [Community, Channel, Message, Task]);

Inherited from

Ad4mModel.registerAll

Defined in

core/src/model/Ad4mModel.ts:2119 (opens in a new tab)

remove

▸ Static remove(this, perspective, id): Promise<void>

Deletes an existing model instance identified by id.

Also cleans up any incoming links that point to this instance.

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `Ad4mModel`	-
`perspective`	`PerspectiveProxy`	The perspective containing the instance
`id`	`string`	The expression URI of the instance to delete

Returns

Promise<void>

Example

await Recipe.delete(perspective, recipeId);

Deprecated

Use the name delete — remove is preserved as an alias.

Inherited from

Ad4mModel.remove

Defined in

core/src/model/Ad4mModel.ts:2054 (opens in a new tab)

transaction

▸ Static transaction<R>(perspective, fn): Promise<R>

Executes a set of model operations inside a single batch (transaction).

All save, update, and delete calls made via the provided batchId are buffered and flushed atomically when the callback completes. If the callback throws, the batch is not committed, preventing partial writes.

Type parameters

Name	Type
`R`	`void`

Parameters

Name	Type	Description
`perspective`	`PerspectiveProxy`	The perspective to operate on
`fn`	(`tx`: { `batchId`: `string` }) => `Promise`<`R`>	Async callback that receives a `TransactionContext` object. Pass `tx.batchId` to `save(tx.batchId)`, `update(tx.batchId)`, `delete(tx.batchId)`, etc.

Returns

Promise<R>

The value returned by fn

Example

await Ad4mModel.transaction(perspective, async (tx) => {
  const recipe = new Recipe(perspective);
  recipe.name = "Spaghetti";
  await recipe.save(tx.batchId);
 
  const old = await Recipe.query(perspective).where({ name: "Stale" }).run();
  for (const r of old) await r.delete(tx.batchId);
});
// All changes committed atomically here

Inherited from

Ad4mModel.transaction

Defined in

core/src/model/Ad4mModel.ts:2153 (opens in a new tab)

update

▸ Static update<T>(this, perspective, id, data): Promise<T>

Updates an existing model instance identified by id.

Fetches the instance, applies the provided changes, calls save(), and returns the refreshed instance.

Type parameters

Name	Type
`T`	extends `Ad4mModel`<`T`>

Parameters

Name	Type	Description
`this`	typeof `Ad4mModel` & (...`args`: `any`[]) => `T`	-
`perspective`	`PerspectiveProxy`	The perspective containing the instance
`id`	`string`	The expression URI of the instance to update
`data`	`Record`<`string`, `any`>	Property values to merge before saving

Returns

Promise<T>

The updated model instance

Example

const recipe = await Recipe.update(perspective, recipeId, {
  rating: 10,
});

Inherited from

Ad4mModel.update

Defined in

core/src/model/Ad4mModel.ts:2026 (opens in a new tab)

Authinfoinput Capability

Class: AutoProcessorConfig

Hierarchy

Table of contents

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

Inherited from

Defined in

Properties

__links

Inherited from

Defined in

author

Inherited from

Defined in

basePrefix

Defined in

batchMax

Defined in

batchMin

Defined in

claimTtlMs

Defined in

createdAt

Inherited from

Defined in

debounceMs

Defined in

dedupStrategy

Defined in

emitDebugEvents

Defined in

existingScope

Defined in

flows

Defined in

interpretationClasses

Defined in

maxToolCalls

Defined in

maxWaitMs

Defined in

mintScope

Defined in

processorId

Defined in

sourceScopeQuery

Defined in

sourceWindowMs

Defined in

updatedAt

Inherited from

Defined in

Accessors

id

Returns

Inherited from

Defined in

perspective

Returns

Inherited from

Defined in

timestamp

Returns

Inherited from

Defined in

Methods

changedFields

Returns

Inherited from

Defined in

delete

Parameters

Returns

Inherited from

Defined in