@coasys/ad4m / Exports

@coasys/ad4m

Enumerations

Classes

Interfaces

Type Aliases

Variables

Decorators Functions

Other Functions

Type Aliases

Ad4mSignalCB

Ƭ Ad4mSignalCB: (signal: any) => void

Type declaration

▸ (signal): void

Parameters

Name	Type
`signal`	`any`

Returns

void

Defined in

language/LanguageContext.ts:37

Address

Ƭ Address: string

Defined in

Address.ts:1

AgentAppsUpdatedCallback

Ƭ AgentAppsUpdatedCallback: () => null

Type declaration

▸ (): null

Returns

null

Defined in

agent/AgentClient.ts:81

AgentStatusChangedCallback

Ƭ AgentStatusChangedCallback: (agent: Agent) => null

Type declaration

▸ (agent): null

Parameters

Name	Type
`agent`	`Agent`

Returns

null

Defined in

agent/AgentClient.ts:80

AgentUpdatedCallback

Ƭ AgentUpdatedCallback: (agent: Agent) => null

Type declaration

▸ (agent): null

Parameters

Name	Type
`agent`	`Agent`

Returns

null

Defined in

agent/AgentClient.ts:79

AllInstancesResult

Ƭ AllInstancesResult: Object

Type declaration

Name	Type
`AllInstances`	`Ad4mModel`[]
`TotalCount?`	`number`

Defined in

model/Ad4mModel.ts:31

DID

Ƭ DID: string

Defined in

DID.ts:1

LinkStatus

Ƭ LinkStatus: "shared" | "local"

Defined in

perspectives/PerspectiveProxy.ts:174

MessageCallback

Ƭ MessageCallback: (message: PerspectiveExpression) => void

Type declaration

▸ (message): void

Parameters

Name	Type
`message`	`PerspectiveExpression`

Returns

void

Defined in

language/Language.ts:192

PaginationResult

Ƭ PaginationResult<T>: Object

Type parameters

Name
`T`

Type declaration

Name	Type
`pageNumber`	`number`
`pageSize`	`number`
`results`	`T`[]
`totalCount?`	`number`

Defined in

model/Ad4mModel.ts:33

PerspectiveDiffObserver

Ƭ PerspectiveDiffObserver: (diff: PerspectiveDiff) => void

Type declaration

▸ (diff): void

Parameters

Name	Type
`diff`	`PerspectiveDiff`

Returns

void

Defined in

language/Language.ts:151

Query

Ƭ Query: Object

Type declaration

Name	Type
`collections?`	`string`[]
`count?`	`boolean`
`limit?`	`number`
`offset?`	`number`
`order?`	`Order`
`properties?`	`string`[]
`source?`	`string`
`where?`	`Where`

Defined in

model/Ad4mModel.ts:20

ResultsWithTotalCount

Ƭ ResultsWithTotalCount<T>: Object

Type parameters

Name
`T`

Type declaration

Name	Type
`results`	`T`[]
`totalCount?`	`number`

Defined in

model/Ad4mModel.ts:32

StatusCallback

Ƭ StatusCallback: (caller: DID) => Perspective

Type declaration

▸ (caller): Perspective

Parameters

Name	Type
`caller`	`DID`

Returns

Perspective

Defined in

language/Language.ts:193

SyncStateChangeObserver

Ƭ SyncStateChangeObserver: (state: PerspectiveState) => void

Type declaration

▸ (state): void

Parameters

Name	Type
`state`	`PerspectiveState`

Returns

void

Defined in

language/Language.ts:152

TelepresenceSignalCallback

Ƭ TelepresenceSignalCallback: (payload: PerspectiveExpression) => void

Type declaration

▸ (payload): void

Parameters

Name	Type
`payload`	`PerspectiveExpression`

Returns

void

Defined in

language/Language.ts:258

Variables

SMART_LITERAL_CONTENT_PREDICATE

• Const SMART_LITERAL_CONTENT_PREDICATE: "smart_literal://content"

Defined in

SmartLiteral.ts:6

typeDefsString

• Const typeDefsString: ""

Defined in

typeDefs.ts:6

Decorators Functions

Collection

▸ Collection(opts): <T>(target: T, key: keyof T) => void

Decorator for defining collections on model classes.

Parameters

Name	Type	Description
`opts`	`CollectionOptions`	Collection configuration

Returns

fn

▸ <T>(target, key): void

Type parameters

Name
`T`

Parameters

Name	Type
`target`	`T`
`key`	keyof `T`

Returns

void

Description

Defines a property that represents a collection of values linked to the model instance. Collections are always arrays and support operations for adding, removing, and setting values.

For each collection property, the following methods are automatically generated:

addX(value) - Add a value to the collection
removeX(value) - Remove a value from the collection
setCollectionX(values) - Replace all values in the collection

Where X is the capitalized property name.

Collections can be filtered using the where option to only include values that:

Are instances of a specific model class
Match a custom Prolog condition

Example

class Recipe extends Ad4mModel {
  // Basic collection of ingredients
  @Collection({ 
    through: "recipe://ingredient" 
  })
  ingredients: string[] = [];
 
  // Collection that only includes instances of another model
  @Collection({
    through: "recipe://comment",
    where: { isInstance: Comment }
  })
  comments: string[] = [];
 
  // Collection with custom filter condition
  @Collection({
    through: "recipe://step",
    where: { condition: `triple(Target, "step://order", Order), Order < 3` }
  })
  firstSteps: string[] = [];
 
  // Local-only collection not shared with network
  @Collection({
    through: "recipe://note",
    local: true
  })
  privateNotes: string[] = [];
}
 
// Using the generated methods:
const recipe = new Recipe(perspective);
await recipe.addIngredients("ingredient://flour");
await recipe.removeIngredients("ingredient://sugar");
await recipe.setCollectionIngredients(["ingredient://butter", "ingredient://eggs"]);

Defined in

model/decorators.ts:459

Flag

▸ Flag(opts): <T>(target: T, key: keyof T) => void

Decorator for defining flags on model classes.

Parameters

Name	Type	Description
`opts`	`FlagOptions`	Flag configuration

Returns

fn

▸ <T>(target, key): void

Type parameters

Name
`T`

Parameters

Name	Type
`target`	`T`
`key`	keyof `T`

Returns

void

Description

A specialized property decorator for defining immutable type flags or markers on model instances. Flags are always required properties with a fixed value that cannot be changed after creation.

Common uses for flags:

Type discrimination between different kinds of models
Marking models with specific capabilities or features
Versioning or compatibility markers

Note: Use of Flag is discouraged unless you specifically need type-based filtering or discrimination between different kinds of models. For most cases, regular properties with

Property

Optional

are more appropriate.

Example

class Message extends Ad4mModel {
  // Type flag to identify message models
  @Flag({
    through: "ad4m://type",
    value: "ad4m://message"
  })
  type: string = "";
 
  // Version flag for compatibility
  @Flag({
    through: "ad4m://version",
    value: "1.0.0"
  })
  version: string = "";
 
  // Feature flag
  @Flag({
    through: "message://feature",
    value: "message://encrypted"
  })
  feature: string = "";
}
 
// Later you can query for specific types:
const messages = await Message.query(perspective)
  .where({ type: "ad4m://message" })
  .run();

Defined in

model/decorators.ts:341

InstanceQuery

▸ InstanceQuery(options?): <T>(target: T, key: keyof T, descriptor: PropertyDescriptor) => void

Decorator for querying instances of a model class.

Parameters

Name	Type	Description
`options?`	`InstanceQueryParams`	Query options

Returns

fn

▸ <T>(target, key, descriptor): void

Type parameters

Name
`T`

Parameters

Name	Type
`target`	`T`
`key`	keyof `T`
`descriptor`	`PropertyDescriptor`

Returns

void

Description

Allows you to define static query methods on your model class to retrieve instances based on custom conditions. This decorator can only be applied to static async methods that return a Promise of an array of model instances.

The query can be constrained using either:

A where clause that matches property values
A custom Prolog condition for more complex queries

Example

class Recipe extends Ad4mModel {
  @Property({ through: "recipe://name" })
  name: string = "";
 
  @Property({ through: "recipe://rating" })
  rating: number = 0;
 
  // Get all recipes
  @InstanceQuery()
  static async all(perspective: PerspectiveProxy): Promise<Recipe[]> { return [] }
 
  // Get recipes by name
  @InstanceQuery({ where: { name: "Chocolate Cake" }})
  static async findByName(perspective: PerspectiveProxy): Promise<Recipe[]> { return [] }
 
  // Get highly rated recipes using a custom condition
  @InstanceQuery({ condition: "triple(Instance, 'recipe://rating', Rating), Rating > 4" })
  static async topRated(perspective: PerspectiveProxy): Promise<Recipe[]> { return [] }
}

Defined in

model/decorators.ts:77

ModelOptions

▸ ModelOptions(opts): (target: any) => void

Decorator for defining model classes in AD4M.

Parameters

Name	Type	Description
`opts`	`ModelOptionsOptions`	Model configuration

Returns

fn

▸ (target): void

Parameters

Name	Type
`target`	`any`

Returns

void

Description

The root decorator that must be applied to any class that represents a model in AD4M. It registers the class as a Social DNA (SDNA) subject class and provides the infrastructure for storing and retrieving instances.

This decorator:

Registers the class with a unique name in the AD4M system
Generates the necessary SDNA code for the model's properties and collections
Enables the use of other model decorators (@Property, @Collection, etc.)
Provides static query methods through the Ad4mModel base class

Example

@ModelOptions({ name: "Recipe" })
class Recipe extends Ad4mModel {
  @Property({
    through: "recipe://name",
    resolveLanguage: "literal"
  })
  name: string = "";
 
  @Collection({ through: "recipe://ingredient" })
  ingredients: string[] = [];
 
  // Static query methods from Ad4mModel:
  static async findByName(perspective: PerspectiveProxy, name: string) {
    return Recipe.query(perspective)
      .where({ name })
      .run();
  }
}
 
// Using the model:
const recipe = new Recipe(perspective);
recipe.name = "Chocolate Cake";
await recipe.save();
 
// Querying instances:
const recipes = await Recipe.query(perspective)
  .where({ name: "Chocolate Cake" })
  .run();
 
// Using with PerspectiveProxy:
await perspective.ensureSDNASubjectClass(Recipe);

Defined in

model/decorators.ts:544

Optional

▸ Optional(opts): <T>(target: T, key: keyof T) => void

Decorator for defining optional properties on model classes.

Parameters

Name	Type	Description
`opts`	`PropertyOptions`	Property configuration options

Returns

fn

▸ <T>(target, key): void

Type parameters

Name
`T`

Parameters

Name	Type
`target`	`T`
`key`	keyof `T`

Returns

void

Description

The most flexible property decorator that allows you to define properties with full control over:

Whether the property is required
Whether the property is writable
How values are stored and retrieved
Custom getter/setter logic
Local vs network storage

Both

Property

and

Read Only

are specialized versions of

Optional

with preset configurations.

Example

class Recipe extends Ad4mModel {
  // Basic optional property
  @Optional({
    through: "recipe://description"
  })
  description?: string;
 
  // Optional property with custom initial value
  @Optional({
    through: "recipe://status",
    initial: "recipe://draft",
    required: true
  })
  status: string = "";
 
  // Read-only property with custom getter
  @Optional({
    through: "recipe://rating",
    writable: false,
    getter: `
      findall(Rating, triple(Base, "recipe://user_rating", Rating), Ratings),
      sum_list(Ratings, Sum),
      length(Ratings, Count),
      Value is Sum / Count
    `
  })
  averageRating: number = 0;
 
  // Property that resolves to a Literal and is stored locally
  @Optional({
    through: "recipe://notes",
    resolveLanguage: "literal",
    local: true
  })
  notes?: string;
 
  // Property with custom getter and setter logic
  @Optional({
    through: "recipe://ingredients",
    getter: `
      triple(Base, "recipe://ingredients", RawValue),
      atom_json_term(RawValue, Value)
    `,
    setter: `
      atom_json_term(Value, JsonValue),
      Actions = [{"action": "setSingleTarget", "source": "this", "predicate": "recipe://ingredients", "target": JsonValue}]
    `
  })
  ingredients: string[] = [];
}

Defined in

model/decorators.ts:249

Property

▸ Property(opts): <T>(target: T, key: keyof T) => void

Decorator for defining required and writable properties on model classes.

Parameters

Name	Type	Description
`opts`	`PropertyOptions`	Property configuration

Returns

fn

▸ <T>(target, key): void

Type parameters

Name
`T`

Parameters

Name	Type
`target`	`T`
`key`	keyof `T`

Returns

void

Description

A convenience decorator that defines a required property that must have an initial value and is writable by default. This is equivalent to using

Optional

with required: true and writable: true.

Properties defined with this decorator:

Must have a value (required)
Can be modified after creation (writable)
Default to "literal://string:uninitialized" if no initial value is provided

Example

class User extends Ad4mModel {
  // Basic required property with default initial value
  @Property({
    through: "user://name"
  })
  name: string = "";
 
  // Required property with custom initial value
  @Property({
    through: "user://status",
    initial: "user://active"
  })
  status: string = "";
 
  // Required property with literal resolution
  @Property({
    through: "user://bio",
    resolveLanguage: "literal"
  })
  bio: string = "";
 
  // Required property with custom getter/setter
  @Property({
    through: "user://age",
    getter: `triple(Base, "user://birthYear", Year), Value is 2024 - Year`,
    setter: `Year is 2024 - Value, Actions = [{"action": "setSingleTarget", "source": "this", "predicate": "user://birthYear", "target": Year}]`
  })
  age: number = 0;
}

Defined in

model/decorators.ts:776

ReadOnly

▸ ReadOnly(opts): <T>(target: T, key: keyof T) => void

Decorator for defining read-only properties on model classes.

Parameters

Name	Type	Description
`opts`	`PropertyOptions`	Property configuration

Returns

fn

▸ <T>(target, key): void

Type parameters

Name
`T`

Parameters

Name	Type
`target`	`T`
`key`	keyof `T`

Returns

void

Description

A convenience decorator that defines a property that can only be read and cannot be modified after initialization. This is equivalent to using

Optional

with writable: false.

Read-only properties are ideal for:

Computed or derived values
Properties that should never change after creation
Properties that are set by the system
Properties that represent immutable data

Example

class Post extends Ad4mModel {
  // Read-only property with custom getter for computed value
  @ReadOnly({
    through: "post://likes",
    getter: `findall(User, triple(Base, "post://liked_by", User), Users), length(Users, Value)`
  })
  likeCount: number = 0;
 
  // Read-only property for creation timestamp
  @ReadOnly({
    through: "post://created_at",
    initial: new Date().toISOString()
  })
  createdAt: string = "";
 
  // Read-only property that resolves to a Literal
  @ReadOnly({
    through: "post://author",
    resolveLanguage: "literal"
  })
  author: string = "";
 
  // Read-only property for system-managed data
  @ReadOnly({
    through: "post://version",
    initial: "1.0.0"
  })
  version: string = "";
}

Defined in

model/decorators.ts:840

Other Functions

ExpressionGeneric

▸ ExpressionGeneric<DataType>(DataTypeClass): any

Type parameters

Name
`DataType`

Parameters

Name	Type
`DataTypeClass`	`ClassType`<`DataType`>

Returns

any

Defined in

expression/Expression.ts:42

ExpressionGenericInput

▸ ExpressionGenericInput<DataType>(DataTypeClass): any

Type parameters

Name
`DataType`

Parameters

Name	Type
`DataTypeClass`	`ClassType`<`DataType`>

Returns

any

Defined in

expression/Expression.ts:67

addLink

▸ addLink(source, predicate, target): PerspectiveAction

Parameters

Name	Type
`source`	`string`
`predicate`	`string`
`target`	`string`

Returns

PerspectiveAction

Defined in

model/decorators.ts:12

capSentence

▸ capSentence(cap): string

Parameters

Name	Type
`cap`	`any`

Returns

string

Defined in

utils.ts:15

exprRef2String

▸ exprRef2String(ref): string

Parameters

Name	Type
`ref`	`ExpressionRef`

Returns

string

Defined in

expression/ExpressionRef.ts:22

formatList

▸ formatList(list): any

Parameters

Name	Type
`list`	`any`

Returns

any

Defined in

utils.ts:1

hasLink

▸ hasLink(predicate): string

Parameters

Name	Type
`predicate`	`string`

Returns

string

Defined in

model/decorators.ts:21

isExpression

▸ isExpression(e): boolean

Parameters

Name	Type
`e`	`any`

Returns

boolean

Defined in

expression/Expression.ts:97

isLink

▸ isLink(l): boolean

Parameters

Name	Type
`l`	`any`

Returns

boolean

Defined in

links/Links.ts:91

linkEqual

▸ linkEqual(l1, l2): boolean

Parameters

Name	Type
`l1`	`LinkExpression`
`l2`	`LinkExpression`

Returns

boolean

Defined in

links/Links.ts:83

makeRandomPrologAtom

▸ makeRandomPrologAtom(length): string

Parameters

Name	Type
`length`	`number`

Returns

string

Defined in

model/decorators.ts:473

parseExprUrl

▸ parseExprUrl(url): ExpressionRef

Parameters

Name	Type
`url`	`string`

Returns

ExpressionRef

Defined in

expression/ExpressionRef.ts:29

Using the AD4M CLI Readme

@coasys/ad4m

Table of contents

Enumerations

Classes

Interfaces

Type Aliases

Variables

Decorators Functions

Other Functions

Type Aliases

Ad4mSignalCB

Type declaration

Parameters

Returns

Defined in

Address

Defined in

AgentAppsUpdatedCallback

Type declaration

Returns

Defined in

AgentStatusChangedCallback

Type declaration

Parameters

Returns

Defined in

AgentUpdatedCallback

Type declaration

Parameters

Returns

Defined in

AllInstancesResult

Type declaration

Defined in

DID

Defined in

LinkStatus

Defined in

MessageCallback

Type declaration

Parameters

Returns

Defined in

PaginationResult

Type parameters

Type declaration

Defined in

PerspectiveDiffObserver

Type declaration

Parameters

Returns

Defined in

Query

Type declaration

Defined in

ResultsWithTotalCount

Type parameters

Type declaration

Defined in

StatusCallback

Type declaration

Parameters

Returns

Defined in

SyncStateChangeObserver

Type declaration

Parameters

Returns

Defined in

TelepresenceSignalCallback

Type declaration

Parameters

Returns

Defined in

Variables

SMART_LITERAL_CONTENT_PREDICATE

Defined in

typeDefsString

Defined in

Decorators Functions