Optionalinit: Partial<BaseEnginePropertyConfig>OptionalAddOptional, whether to add the result to the object, defaults to true if not specified
OptionalAutoOptional, defaults to true. If set to false, AutoRefresh for this item will be disabled. By default, whenever a BaseEntity event is emitted for a save/delete, if the entity name for this config matches the BaseEntity's entity name, the config will be refreshed. If this is set to false, that will not happen. NOTE: This is not a network notification mechanism, it only works within the local tier, so for example within a browser application, that brower's engine sub-classes will be updated when changes are made to entities in that application environment, and the same is true for MJAPI/Server based environments. If you need network based notification, additional infrastructure will be needed to implement that.
OptionalCacheWhen set to true, the engine will use the LocalCacheManager to cache results locally. On subsequent loads (unless forceRefresh is true), cached results will be validated via smart cache check and returned from local storage if still current.
OptionalCacheOptional TTL (time-to-live) in milliseconds for locally cached results when CacheLocal is true. After this time, cached results will be considered stale and fresh data will be fetched. If not specified, the LocalCacheManager's default TTL will be used (typically 5 minutes).
OptionalDatasetOptional, filters to apply to each item in a dataset, only applies when type is 'dataset' and is optional in those cases.
OptionalDatasetThe dataset name to load from the database, required if Type is 'dataset'
OptionalDatasetOptional, only used if Type is 'dataset', specifies how to handle the results of the dataset load. Defaults to 'single_property' if not specified. When set to 'single_property', the entire dataset is set to the property specified by PropertyName. When set to 'individual_properties', each item in the dataset is set to a property on the object with the name of the item's key plus the item's Code name. For example, if the item's key is 'Demo' and the item's Code name is 'FirstItem', the property set on the object would be 'Demo_FirstItem'.
OptionalDebounceOptional debounce time in milliseconds for this specific config. If not specified, uses the engine's default EntityEventDebounceTime (5000ms). This allows different entities to have different debounce delays.
OptionalEntityThe entity name to load from the database, required if Type is 'entity'
OptionalExpirationOptional, expiration time in milliseconds
OptionalFilterOptional, filters to apply to the data load, applies only when type is 'entity'. Use DatasetItemFilters for dataset filters.
Primary Key
OptionalIncludeWhether the engine loads the entity's binary fields (varbinary / bytea columns, held as
base64 strings) along with the rest. Engines leave them out by default, like every RunView,
so a cached entity never carries large embeddings or file content it does not use.
true — always load them.'DatabaseProviderOnly' — load them only when the engine runs on a database provider
(the server), never over a network provider (the browser). Use this for an engine shared
by both tiers where only server code reads the binary values — e.g. persisted embeddings
that only the server indexes — so the browser never downloads them.false / omitted — never load them.OptionalOrderOptional, order by clause to apply to the data load, only applies when type is 'entity'
The name of the property in the class instance
OptionalResultControls whether loaded rows are returned as full BaseEntity subclass instances ('entity_object') or plain JavaScript objects ('simple').
Resolution order when this property is left undefined:
In other words, the effective default is 'entity_object' — leaving this undefined preserves the historical behavior. Do NOT initialize this field to a literal value here; it must remain undefined so the engine-level default can take effect.
The type of item to load, either 'entity' or 'dataset', defaults to 'entity'
The metadata provider that built this Info object, when known.
Info getters that resolve sibling metadata (an entity's IS-A children, a permission's RLS
filter, a query's fields, an authorization's roles, …) must read from the SAME provider the
object came from. In a multi-provider process — several GraphQLDataProvider instances with
separateConnection, or a server servicing several connections — the global
Metadata.Provider is a different provider or not set at all. Providers pass themselves to
every Info constructor (new m.class(row, provider)), and container Info objects hand it to
the child Info objects they construct.
undefined for an Info object built outside a provider (tests, ad-hoc construction). Callers
then fall back to the global provider, which is exactly the pre-existing behavior.
ProtectedcopyCopies initialization data from a plain object to the class instance. Only copies properties that already exist on the class to prevent creating new fields. Special handling for DefaultValue fields to extract actual values from SQL Server syntax.
The initialization data object
OptionalskipKeys: ReadonlySet<string>Optional set of property keys handled directly by the subclass constructor
Records the provider that owns this Info object. A null/undefined provider is ignored, so passing an optional constructor argument straight through is always safe.
the provider whose metadata this object belongs to
Default JSON serialization for BaseInfo subclasses.
Emits all non-underscored direct field declarations. For _-prefixed private backing fields
(the MJ pattern for collection storage — e.g. _Fields, _RelatedEntities, _OrganicKeys),
emits the value of the corresponding same-named public getter instead. Purely computed getters
without a backing field (display-name formatters, derived flags) are intentionally skipped —
they can throw when source fields are null and don't belong on the wire anyway.
A _-backed getter that throws is omitted from the output rather than aborting the whole
serialization. That omission is safe ONLY because such getters are recomputable: the backing
field is a lazy cache over other serialized state (e.g. QueryInfo.CategoryPath over CategoryID),
so the value is rebuilt on the next access after a warm boot. Do not add a _-backed getter
whose value cannot be recomputed from the serialized fields — a throw would silently drop it.
Nested BaseInfo instances and arrays of them unwrap automatically via JSON.stringify's native toJSON() protocol.
Subclasses may override to emit a filtered subset or custom shape (see EntityFieldValueInfo).
Property configuration for the BaseEngine class to automatically load/set properties on the class.