@salsita-ai/sdk 0.50.0-develop.bfba230ad7 → 0.50.0-develop.c28cfb7ded

package/dist/domain/core/data-schema/data-schema-primitive-field.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/data-schema/data-schema.d.ts

@@ -0,0 +1,2 @@
+import type { DataSchemaField } from './data-schema-field.js';
+export type DataSchema = Record<string, DataSchemaField>;

package/dist/domain/core/data-schema/data-schema.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/data-schema/index.d.ts

@@ -0,0 +1,7 @@
+export type * from './data-cell-value.js';
+export type * from './data-schema-array-field.js';
+export type * from './data-schema-field-object.js';
+export type * from './data-schema-field.js';
+export type * from './data-schema-localized-field.js';
+export type * from './data-schema-primitive-field.js';
+export type * from './data-schema.js';

package/dist/domain/core/data-schema/index.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/decoder/create-decoder.d.ts

@@ -0,0 +1,6 @@
+import type { Decoder } from './decoder.js';
+/**
+ * Creates the decoder of data that must match a JSON schema. `subject` is what the data is, as the
+ * error names it, for example `Session data`.
+ */
+export declare const createDecoder: <DATA>(schema: object, subject: string) => Decoder<DATA>;

package/dist/domain/core/decoder/create-decoder.js

@@ -0,0 +1 @@
+import{extendedSchemaValidator as r}from"../schema/index.js";export const createDecoder=(e,o)=>t=>{let i=r.compile(e);if(!i(t))throw Error(`${o} is not valid: ${r.errorsText(i.errors)}`);return t};

package/dist/domain/core/decoder/decoder.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Turns data of unknown shape into data of a known type, and throws when the data does not match.
+ * Everything that enters a domain from outside goes through one: published, session, frontend and
+ * backend data.
+ */
+export type Decoder<DATA> = (data: unknown) => DATA;

package/dist/domain/core/decoder/decoder.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/decoder/index.d.ts

@@ -0,0 +1,2 @@
+export { createDecoder } from './create-decoder.js';
+export type { Decoder } from './decoder.js';

package/dist/domain/core/decoder/index.js

@@ -0,0 +1 @@
+export{createDecoder}from"./create-decoder.js";

package/dist/domain/core/domain-factory.d.ts

@@ -1,9 +1,8 @@
 import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
-import type { ActionDefinitions, AnyActionImplementations } from './action.js';
-import type { Expression } from './expression.js';
-import type { MigrateFunction } from './migrations.js';
-import type { $DomainEntity, DomainEntity, EntityByType } from './model.js';
-import type { $DomainEntityReflection, EntityReflections, SchemaOfObject } from './reflection.js';
+import type { ActionDefinitions, AnyActionImplementations } from './action/index.js';
+import type { Expression } from './expression/index.js';
+import type { $DomainEntity, $DomainEntityReflection, DomainEntity, EntityByType, EntityReflections, SchemaOfObject } from './model/index.js';
+import type { MigrateFunction } from './state/index.js';
 type $EntityReflections<ENTITIES extends DomainEntity<string>> = {
     [TYPE in ENTITIES['type']]: $DomainEntityReflection<$DomainEntity<EntityByType<ENTITIES, TYPE>>>;
 };

package/dist/domain/core/domain-factory.js

@@ -1 +1 @@
-import{migrateCommonAdminDomain as t}from"../admin-domain/implementation/common-admin-migrations.js";import{extendedSchemaValidator as r}from"./json-schema.js";export class DomainFactory{context;modelVersion;hasBackendData;constructor(t){this.context=t,this.modelVersion=t.modelVersion,this.hasBackendData=void 0!==t.backendData}parsePublishedData=t=>{let e=r.compile(this.context.publishedData);if(!e(t))throw Error(`Admin data is not valid: ${r.errorsText(e.errors)}`);return t};parseSessionData=t=>{let e=r.compile(this.context.sessionData);if(!e(t))throw Error(`Session data is not valid: ${r.errorsText(e.errors)}`);return t};parseFrontendData=t=>{let e=r.compile(this.context.frontendData);if(!e(t))throw Error(`Frontend data is not valid: ${r.errorsText(e.errors)}`);return t};parseBackendData=t=>{if(void 0===this.context.backendData)throw Error("Backend data is not supported for this domain");let e=r.compile(this.context.backendData);if(!e(t))throw Error(`Backend data is not valid: ${r.errorsText(e.errors)}`);return t};validateAndMigrateState=(r,e)=>{let a=this.context.isAdminDomain?t(r):r;return this.context.migrate({state:a,version:e},{trimExtraProperties:!1})}}
+import{migrateCommonAdminDomain as t}from"../admin-domain/implementation/common-admin-migrations.js";import{createDecoder as a}from"./decoder/index.js";export class DomainFactory{context;modelVersion;hasBackendData;constructor(t){this.context=t,this.modelVersion=t.modelVersion,this.hasBackendData=void 0!==t.backendData}parsePublishedData=t=>a(this.context.publishedData,"Admin data")(t);parseSessionData=t=>a(this.context.sessionData,"Session data")(t);parseFrontendData=t=>a(this.context.frontendData,"Frontend data")(t);parseBackendData=t=>{if(void 0===this.context.backendData)throw Error("Backend data is not supported for this domain");return a(this.context.backendData,"Backend data")(t)};validateAndMigrateState=(a,e)=>{let n=this.context.isAdminDomain?t(a):a;return this.context.migrate({state:n,version:e},{trimExtraProperties:!1})}}

package/dist/domain/core/domain.d.ts

@@ -1,7 +1,6 @@
-import type { AnyExpressions, ExpressionContext } from './expression.js';
-import { type $DomainEntity, type DomainEntity, type DomainEntityId, type EntityByType } from './model.js';
-import type { AnyEntityReflections } from './reflection.js';
-import type { DomainState } from './state.js';
+import type { AnyExpressions, OpenExpressionContext } from './expression/index.js';
+import { type $DomainEntity, type AnyEntityReflections, type DomainEntity, type DomainEntityId, type EntityByType } from './model/index.js';
+import type { DomainState } from './state/index.js';
 export type AllowedRootEntityTypes<ALLOWED_ROOT_ENTITIES extends DomainEntity<string>> = ReadonlyArray<ALLOWED_ROOT_ENTITIES['type']>;
 export type AnyAllowedRootEntityTypes = AllowedRootEntityTypes<DomainEntity<string>>;
 /**
@@ -13,7 +12,7 @@ export interface DomainSelectors {
     readonly getDomainExpressions: () => AnyExpressions;
     readonly getAllowedRootEntityTypes: () => ReadonlyArray<string>;
     readonly getEntityReflections: () => AnyEntityReflections;
-    readonly getExpressionContext: () => ExpressionContext<any, any, any, any, any>;
+    readonly getExpressionContext: () => OpenExpressionContext<any, any, any, any, any>;
 }
 /** Effective mode used by domain expressions and systems. */
 export type DomainMode = 'owner' | 'read' | 'finalize';

package/dist/domain/core/domain.js

@@ -1 +1 @@
-import{createCacheToken as t,getStickyCache as e}from"@salsita-ai/common/utils";import{domainEntityTypeFromId as i}from"./model.js";let r=t(),o=t();export class Domain{_context;constructor(t){this._context=t}getEntity=(t,i)=>{let r=e(i,o),n=r.get("entityMap");if(n)return n.get(t);let s=(t=>{let e=new Map;for(let i of t){if(e.has(i.id))throw Error(`Error while creating a UniqueEntityMap for caching of domain queries. Duplicate entity id ${i.id} encountered!`);e.set(i.id,i)}return e})(i.entities);return r.put("entityMap",s),s.get(t)};get$Entity=(t,i)=>{let o=e(i,r),n=o.get(t);if(n)return n;let s=this.getEntity(t,i);if(!s)throw Error(`Entity ${t} does not exist`);let a={...s},l=this._context.selectors.getDomainExpressions()[s.type];return l&&Object.entries(l).forEach(([t,e])=>{Object.defineProperty(a,t,{enumerable:!0,get:()=>e.evaluate(s.id,i,this._context.selectors.getExpressionContext())})}),Object.defineProperty(a,"_raw",{enumerable:!0,writable:!1,value:s}),Object.defineProperty(a,"_state",{enumerable:!0,writable:!1,value:i}),o.put(t,a),a};get$Entities=(t,e)=>t.map(t=>this.get$Entity(t,e));getRoot$Entity=t=>this.get$Entity(t.rootEntityId,t);validateExpressions=t=>{if(!this._context.selectors.getAllowedRootEntityTypes().includes(t.rootEntityType))throw Error(`Entity type ${t.rootEntityType} is not allowed as root entity`);if(!this.getEntity(t.rootEntityId,t))throw Error(`Root entity ${t.rootEntityId} was not found!`);t.entities.forEach(e=>{let i=this._context.selectors.getDomainExpressions()[e.type];void 0!==i&&Object.values(i).forEach(i=>{!0===i.meta.alwaysEvaluate&&i.evaluate(e.id,t,this._context.selectors.getExpressionContext())})})};validateEntity=t=>{let e=this._context.selectors.getEntityReflections()[t.type];if(!e)throw Error(`Unknown entity type ${t.type}`);return e._meta.validator(t)?{success:!0}:{success:!1,errors:e._meta.validator.errors?.map(t=>`${t.instancePath} ${t.message}`.trim())??[]}};getWritableEntityKeys=(t,e)=>{let r=i(t),o=this._context.selectors.getDomainExpressions()[r];return e.filter(t=>"id"!==t&&"type"!==t&&"_raw"!==t&&o?.[t]===void 0)}}
+import{createCacheToken as t,getStickyCache as e}from"@salsita-ai/common/utils";import{domainEntityTypeFromId as i}from"./model/index.js";let r=t(),o=t();export class Domain{_context;constructor(t){this._context=t}getEntity=(t,i)=>{let r=e(i,o),n=r.get("entityMap");if(n)return n.get(t);let s=(t=>{let e=new Map;for(let i of t){if(e.has(i.id))throw Error(`Error while creating a UniqueEntityMap for caching of domain queries. Duplicate entity id ${i.id} encountered!`);e.set(i.id,i)}return e})(i.entities);return r.put("entityMap",s),s.get(t)};get$Entity=(t,i)=>{let o=e(i,r),n=o.get(t);if(n)return n;let s=this.getEntity(t,i);if(!s)throw Error(`Entity ${t} does not exist`);let a={...s},l=this._context.selectors.getDomainExpressions()[s.type];return l&&Object.entries(l).forEach(([t,e])=>{Object.defineProperty(a,t,{enumerable:!0,get:()=>e.evaluate(s.id,i,this._context.selectors.getExpressionContext())})}),Object.defineProperty(a,"_raw",{enumerable:!0,writable:!1,value:s}),Object.defineProperty(a,"_state",{enumerable:!0,writable:!1,value:i}),o.put(t,a),a};get$Entities=(t,e)=>t.map(t=>this.get$Entity(t,e));getRoot$Entity=t=>this.get$Entity(t.rootEntityId,t);validateExpressions=t=>{if(!this._context.selectors.getAllowedRootEntityTypes().includes(t.rootEntityType))throw Error(`Entity type ${t.rootEntityType} is not allowed as root entity`);if(!this.getEntity(t.rootEntityId,t))throw Error(`Root entity ${t.rootEntityId} was not found!`);t.entities.forEach(e=>{let i=this._context.selectors.getDomainExpressions()[e.type];void 0!==i&&Object.values(i).forEach(i=>{!0===i.meta.alwaysEvaluate&&i.evaluate(e.id,t,this._context.selectors.getExpressionContext())})})};validateEntity=t=>{let e=this._context.selectors.getEntityReflections()[t.type];if(!e)throw Error(`Unknown entity type ${t.type}`);return e._meta.validator(t)?{success:!0}:{success:!1,errors:e._meta.validator.errors?.map(t=>`${t.instancePath} ${t.message}`.trim())??[]}};getWritableEntityKeys=(t,e)=>{let r=i(t),o=this._context.selectors.getDomainExpressions()[r];return e.filter(t=>"id"!==t&&"type"!==t&&"_raw"!==t&&o?.[t]===void 0)}}

package/dist/domain/core/emission/index.d.ts

@@ -0,0 +1,8 @@
+export type * from './reset-state-emission.js';
+export type * from './state-emission.js';
+export type * from './state-update-emission.js';
+export type * from './state-validation-result.js';
+export type * from './transformation-log.js';
+export type * from './transformer-log-entry.js';
+export type * from './transformer-log.js';
+export type * from './transformer-phase.js';

package/dist/domain/core/emission/index.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/reset-state-emission.d.ts

@@ -0,0 +1,12 @@
+import type { ViolationTypesOf$Entity } from '../invariant/index.js';
+import type { $DomainEntity, DomainEntity } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+import type { StateValidationResult } from './state-validation-result.js';
+import type { TransformationLog } from './transformation-log.js';
+export interface ResetStateEmission<ENTITIES extends DomainEntity<string>, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>> {
+    readonly kind: 'reset';
+    readonly state: DomainState<ENTITIES>;
+    readonly validity: StateValidationResult<ENTITIES, ViolationTypesOf$Entity<$MAP[ENTITIES['type']]>>;
+    readonly tag: unknown;
+    readonly transformationLog: TransformationLog | undefined;
+}

package/dist/domain/core/emission/reset-state-emission.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/state-emission.d.ts

@@ -0,0 +1,4 @@
+import type { $DomainEntity, DomainEntity } from '../model/index.js';
+import type { ResetStateEmission } from './reset-state-emission.js';
+import type { StateUpdateEmission } from './state-update-emission.js';
+export type StateEmission<ENTITIES extends DomainEntity<string>, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>> = ResetStateEmission<ENTITIES, $MAP> | StateUpdateEmission<ENTITIES, $MAP>;

package/dist/domain/core/emission/state-emission.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/state-update-emission.d.ts

@@ -0,0 +1,14 @@
+import type { DataUpdate } from '../component/index.js';
+import type { ViolationTypesOf$Entity } from '../invariant/index.js';
+import type { $DomainEntity, DomainEntity } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+import type { StateValidationResult } from './state-validation-result.js';
+import type { TransformationLog } from './transformation-log.js';
+export interface StateUpdateEmission<ENTITIES extends DomainEntity<string>, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>> {
+    readonly kind: 'staged' | 'committed';
+    readonly previousState: DomainState<ENTITIES>;
+    readonly state: DomainState<ENTITIES>;
+    readonly updates: ReadonlyArray<DataUpdate<ENTITIES, ENTITIES>>;
+    readonly validity: StateValidationResult<ENTITIES, ViolationTypesOf$Entity<$MAP[ENTITIES['type']]>>;
+    readonly transformationLog: TransformationLog | undefined;
+}

package/dist/domain/core/emission/state-update-emission.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/state-validation-result.d.ts

@@ -0,0 +1,18 @@
+import type { EntityViolation } from '../invariant/index.js';
+import type { DomainEntity } from '../model/index.js';
+export type StateValidationResult<ENTITIES extends DomainEntity<string>, VIOLATION_TYPE extends string> = {
+    readonly valid: true;
+    readonly severity: null;
+} | {
+    readonly valid: true;
+    readonly severity: 'warning' | 'notice';
+    readonly entityViolations: ReadonlyArray<EntityViolation<ENTITIES, VIOLATION_TYPE>>;
+} | {
+    readonly valid: false;
+    readonly severity: 'uncaught';
+    readonly error: Error;
+} | {
+    readonly valid: false;
+    readonly severity: 'fatal' | 'fixable';
+    readonly entityViolations: ReadonlyArray<EntityViolation<ENTITIES, VIOLATION_TYPE>>;
+};

package/dist/domain/core/emission/state-validation-result.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/transformation-log.d.ts

@@ -0,0 +1,2 @@
+import type { TransformerLog } from './transformer-log.js';
+export type TransformationLog = readonly TransformerLog[];

package/dist/domain/core/emission/transformation-log.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/transformer-log-entry.d.ts

@@ -0,0 +1,6 @@
+import type { TransformerPhase } from './transformer-phase.js';
+export interface TransformerLogEntry {
+    phase: TransformerPhase;
+    message: string;
+    data: unknown | undefined;
+}

package/dist/domain/core/emission/transformer-log-entry.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/transformer-log.d.ts

@@ -0,0 +1,11 @@
+import type { StateUpdate } from '../component/index.js';
+import type { DomainEntity } from '../model/index.js';
+import type { TransformerLogEntry } from './transformer-log-entry.js';
+import type { TransformerPhase } from './transformer-phase.js';
+export interface TransformerLog {
+    name: string;
+    entries: readonly TransformerLogEntry[];
+    status: TransformerPhase;
+    updatesIn: ReadonlyArray<StateUpdate<DomainEntity<string>, DomainEntity<string>>>;
+    updatesOut: ReadonlyArray<StateUpdate<DomainEntity<string>, DomainEntity<string>>>;
+}

package/dist/domain/core/emission/transformer-log.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/emission/transformer-phase.d.ts

@@ -0,0 +1 @@
+export type TransformerPhase = 'no-event' | 'no-match' | 'no-resolve' | 'match' | 'no-apply' | 'apply';

package/dist/domain/core/emission/transformer-phase.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/expression/aliased-expressions.d.ts

@@ -0,0 +1,10 @@
+import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
+import type { AnonymousExpression } from './expression.js';
+/**
+ * The expressions a project implements, keyed by entity type or alias and then by expression name.
+ * It is what `implementCustomExpressions` returns and what the domain is built from; an alias key
+ * stands for every entity type the alias expands to.
+ */
+export type AliasedExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, CONTEXT_EXTENSION = unknown> = {
+    [K in TypeOrAlias<ENTITIES, ALIASES>]?: Record<string, AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, unknown, CONTEXT_EXTENSION>>;
+};

package/dist/domain/core/expression/aliased-expressions.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/expression/constant-expressions.d.ts

@@ -0,0 +1,16 @@
+import type { ExpressionMeta } from './expression.js';
+/**
+ * The constant expressions of a domain, keyed by entity type or alias and then by the name of the
+ * constant. A constant expression takes no argument: it reads neither the entity nor the state, so
+ * the domain of any project accepts it.
+ */
+export type ConstantExpressions = Readonly<Record<string, Readonly<Record<string, {
+    evaluate(): unknown;
+    readonly meta: ExpressionMeta;
+}>>>>;
+/**
+ * Makes the function that turns the constants of a spec into expressions: every constant becomes an
+ * expression that returns its value. The type a project reads from a constant is the one its
+ * generated model declares for the property, not the type of the expression.
+ */
+export declare const createConstantExpressionFactory: () => (constants: Readonly<Record<string, Readonly<Record<string, unknown>>>>) => ConstantExpressions;

package/dist/domain/core/expression/constant-expressions.js

@@ -0,0 +1 @@
+import{mapNestedObject as t}from"../../utils/map-nested-object.js";export const createConstantExpressionFactory=()=>e=>t()(e,([t,e,o])=>[[t,e,{meta:{},evaluate:()=>o}]]);

package/dist/domain/core/expression/custom-expression.d.ts

@@ -0,0 +1,25 @@
+import type { $DomainEntity, DomainEntity, DomainEntityId, TypeOrAlias } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+import type { AliasedExpressions } from './aliased-expressions.js';
+import type { ExpressionMeta, OpenExpressionContext } from './expression.js';
+export type CustomExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends $DomainEntity<ENTITIES>, T, CONTEXT_EXTENSION = unknown> = (self: SELF, state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>) => T;
+export type PotentialCustomExpressions<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, CONTEXT_EXTENSION = unknown> = {
+    [TYPE_OR_ALIAS in keyof $MAP]?: {
+        [NAME in Extract<keyof $MAP[TYPE_OR_ALIAS], `$${string}`>]?: CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], $MAP[TYPE_OR_ALIAS][NAME], CONTEXT_EXTENSION>;
+    };
+};
+export declare const createCustomExpressionFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, CONTEXT_EXTENSION = unknown>() => (implementations: PotentialCustomExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>) => AliasedExpressions<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, CONTEXT_EXTENSION>;
+/**
+ * Wraps the function a project writes for an expression or for a filter criterion into an
+ * expression: the function receives the entity view of `selfId` instead of the id. It takes the
+ * types of the function as they are, so the expression it returns has the state and the context of
+ * the function, and it asks of the context only the entity view it reads itself.
+ */
+export declare const createCustomExpression: <SELF, STATE, CONTEXT extends {
+    readonly domain: {
+        get$Entity(id: DomainEntityId<string>, state: STATE): unknown;
+    };
+}, T>(evaluate: (self: SELF, state: STATE, ctx: CONTEXT) => T, meta: ExpressionMeta) => {
+    evaluate(selfId: DomainEntityId<string>, state: STATE, ctx: CONTEXT): T;
+    readonly meta: ExpressionMeta;
+};

package/dist/domain/core/expression/custom-expression.js

@@ -0,0 +1 @@
+import{mapNestedObject as e}from"../../utils/map-nested-object.js";export const createCustomExpressionFactory=()=>t=>e()(t,([e,t,o])=>{if(!o)throw Error(`Custom expression for ${e}.${t} is of type undefined`);return[[e,t,createCustomExpression(o,{})]]});export const createCustomExpression=(e,t)=>({evaluate:(t,o,r)=>e(r.domain.get$Entity(t,o),o,r),meta:t});

package/dist/domain/core/expression/expression.d.ts

@@ -0,0 +1,46 @@
+import type { SessionRole } from '@salsita-ai/contracts/api';
+import type { Domain } from '../domain.js';
+import type { $DomainEntity, DomainEntity } from '../model/index.js';
+import type { DomainState, MigrateFunction } from '../state/index.js';
+/**
+ * The part of the expression context that core declares: the mode and role of the session, the data
+ * of the application, the entity view and the migration of the model.
+ */
+export interface CoreExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>> {
+    readonly mode: 'owner' | 'read' | 'finalize';
+    readonly role: SessionRole;
+    readonly publishedData: PUBLISHED_DATA;
+    readonly frontendData: FRONTEND_DATA;
+    readonly backendData: Record<string, unknown> | undefined;
+    readonly sessionData: SESSION_DATA;
+    readonly domain: Domain<ENTITIES, ALLOWED_ROOT_ENTITIES, Record<ENTITIES['type'], $DomainEntity<ENTITIES>>>;
+    readonly migrate: MigrateFunction<ENTITIES>;
+}
+/**
+ * The context an expression is evaluated in. Core declares its own part; `CONTEXT_EXTENSION` is
+ * what whoever evaluates the expression adds to it, such as the component reader and the
+ * projections of the domain runtime. An expression that reads only core's part leaves it out.
+ */
+export type OpenExpressionContext<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, CONTEXT_EXTENSION = unknown> = CoreExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA> & CONTEXT_EXTENSION;
+export interface ExpressionMeta {
+    /**
+     * By enabling this flag, expression will be run during validation. It is primarily used to check validity of relations.
+     */
+    readonly alwaysEvaluate?: boolean;
+}
+/**
+ * Metadata used for debugging of expression exceptions.
+ */
+export interface ExpressionOrigin {
+    readonly typeOrAlias: string;
+    readonly name: string;
+}
+export interface AnonymousExpression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T, CONTEXT_EXTENSION = unknown> {
+    evaluate(selfId: SELF['id'], state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>): T;
+    readonly meta: ExpressionMeta;
+}
+export interface Expression<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, SELF extends ENTITIES, T, CONTEXT_EXTENSION = unknown> extends AnonymousExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, SELF, T, CONTEXT_EXTENSION> {
+    readonly origin: ExpressionOrigin;
+}
+export type AnyExpression = Expression<any, any, any, any, any, any, any>;
+export type AnyExpressions = Record<string, Record<string, AnyExpression>>;

package/dist/domain/core/expression/expression.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/expression/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './aliased-expressions.js';
+export * from './constant-expressions.js';
+export * from './custom-expression.js';
+export type * from './expression.js';

package/dist/domain/core/expression/index.js

@@ -0,0 +1 @@
+export*from"./constant-expressions.js";export*from"./custom-expression.js";

package/dist/domain/core/index.d.ts

@@ -1,18 +1,14 @@
-export type { EnhancedJsonObjectSchemaType, EnhancedJsonSchemaType, JsonSchemaType, MemberImport, } from './enhanced-json-schema.js';
-export type { ActionContext, ActionDefinition, ActionDefinitions, ActionImplementation, ActionImplementations, ActionStateChange, ActionTypes, AnyActionContext, AnyActionImplementation, AnyActionImplementations, PreparedAction, } from './action.js';
-export { extendedSchemaValidator, getExtendedSchemaValidator } from './json-schema.js';
-export { _unsafeBuildDomainEntityId, domainEntityTypeFromId, createVirtualEntityId, isDomainEntityId, isVirtualEntityId, VirtualEntityIdSchema, isEqualEntityTypeAndId, parseDomainEntityId, DomainEntityIdSchema, DomainEntitySchema, $DomainEntitySchema, } from './model.js';
-export type { $DomainEntity, DomainEntity, VirtualEntityId, DomainEntityId, EntityIdSchema, EntityByType, EntityId, } from './model.js';
-export type { PartialSchemaOfObject, SchemaOfObject, EnumLike, EntityReflections } from './reflection.js';
-export { type Migration, MigrateFunctionBuilder, type MigrateFunction, type VersionedState, type MigrateFunctionOptions, type AnyVersionedState, StateMigrationError, isStateMigrationError, } from './migrations.js';
-export * from './reflection.js';
-export type { ComponentInstance, StateOfComponent, WritableStateOfComponent, SystemComponentType, SystemComponentTypeConstraint, ComponentSnapshot, } from './component.js';
-export { isEqualComponentInstance, areEqualComponentSnapshots, isEqualComponentSnapshot, isSnapshotOfComponentType, isInstanceOfComponentType, getComponentInstanceKey, getComponentSnapshotKey, } from './component.js';
-export { type DomainState, type DomainStateFactory, createInitialDomainState } from './state.js';
-export type * from './expression.js';
-export * from './alias.js';
-export * from './domain.js';
+export * from './action/index.js';
+export * from './component/index.js';
+export type * from './data-schema/index.js';
+export * from './decoder/index.js';
 export * from './domain-factory.js';
-export * from './preset.js';
-export { getCommonPhxDefinitions, availableDefinitions } from './common-definitions.js';
-export type { PhxValidateFunction, PhxValidationError, SchemaValidator } from './schema-validator.js';
+export * from './domain.js';
+export type * from './emission/index.js';
+export * from './expression/index.js';
+export * from './invariant/index.js';
+export * from './model/index.js';
+export * from './recipe/index.js';
+export * from './relation/index.js';
+export * from './schema/index.js';
+export * from './state/index.js';

package/dist/domain/core/index.js

@@ -1 +1 @@
-export{extendedSchemaValidator,getExtendedSchemaValidator}from"./json-schema.js";export{_unsafeBuildDomainEntityId,domainEntityTypeFromId,createVirtualEntityId,isDomainEntityId,isVirtualEntityId,VirtualEntityIdSchema,isEqualEntityTypeAndId,parseDomainEntityId,DomainEntityIdSchema,DomainEntitySchema,$DomainEntitySchema}from"./model.js";export{MigrateFunctionBuilder,StateMigrationError,isStateMigrationError}from"./migrations.js";export*from"./reflection.js";export{isEqualComponentInstance,areEqualComponentSnapshots,isEqualComponentSnapshot,isSnapshotOfComponentType,isInstanceOfComponentType,getComponentInstanceKey,getComponentSnapshotKey}from"./component.js";export{createInitialDomainState}from"./state.js";export*from"./alias.js";export*from"./domain.js";export*from"./domain-factory.js";export*from"./preset.js";export{getCommonPhxDefinitions,availableDefinitions}from"./common-definitions.js";
+export*from"./action/index.js";export*from"./component/index.js";export*from"./decoder/index.js";export*from"./domain-factory.js";export*from"./domain.js";export*from"./expression/index.js";export*from"./invariant/index.js";export*from"./model/index.js";export*from"./recipe/index.js";export*from"./relation/index.js";export*from"./schema/index.js";export*from"./state/index.js";

package/dist/domain/{invariants → core/invariant}/builtin-invariant.d.ts

@@ -1,5 +1,5 @@
-import type { DomainEntity, DomainEntityId } from '../core/model.js';
-import type { DomainState } from '../core/state.js';
+import type { DomainEntity, DomainEntityId } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
 import type { Invariant } from './invariants.js';
 import type { Violation } from './violation.js';
 export declare const createInvariant: <VIOLATION_TYPE extends string>(evaluate: (selfId: DomainEntityId<string>, state: DomainState<DomainEntity<string>>) => ReadonlyArray<Violation<VIOLATION_TYPE>>) => Invariant<DomainEntity<string>, DomainEntity<string>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, DomainEntity<string>, VIOLATION_TYPE>;

package/dist/domain/core/invariant/custom-invariants.d.ts

@@ -0,0 +1,13 @@
+import type { CustomExpression } from '../expression/index.js';
+import type { $DomainEntity, DomainEntity, TypeOrAlias } from '../model/index.js';
+import type { AliasedInvariants } from './invariants.js';
+import type { Violation } from './violation.js';
+export type CustomInvariantsFromBlueprints<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<ENTITIES['type'], $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, BLUEPRINTS extends Partial<Record<keyof $MAP & string, Record<string, boolean | string>>>, CONTEXT_EXTENSION = unknown> = {
+    [TYPE_OR_ALIAS in keyof BLUEPRINTS]: {
+        [NAME in keyof BLUEPRINTS[TYPE_OR_ALIAS]]: TYPE_OR_ALIAS extends keyof $MAP ? CustomExpression<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, $MAP[TYPE_OR_ALIAS], BLUEPRINTS[TYPE_OR_ALIAS][NAME] extends string ? ReadonlyArray<Violation<BLUEPRINTS[TYPE_OR_ALIAS][NAME]>> : BLUEPRINTS[TYPE_OR_ALIAS][NAME], CONTEXT_EXTENSION> : never;
+    };
+};
+/** The violation a static invariant reports when it does not hold, by entity type or alias and by invariant name. */
+type StaticViolations = Readonly<Record<string, Readonly<Record<string, Violation<string>>>>>;
+export declare const createCustomInvariantFactory: <ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, $MAP extends Record<TypeOrAlias<ENTITIES, ALIASES>, $DomainEntity<ENTITIES>>, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, BLUEPRINTS extends Partial<Record<TypeOrAlias<ENTITIES, ALIASES>, Record<string, boolean | string>>>, CONTEXT_EXTENSION = unknown>() => (staticViolations: StaticViolations) => <TYPES_OR_ALIASES extends keyof BLUEPRINTS & string>(implementations: Pick<CustomInvariantsFromBlueprints<ENTITIES, ALLOWED_ROOT_ENTITIES, $MAP, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, BLUEPRINTS, CONTEXT_EXTENSION>, TYPES_OR_ALIASES>) => AliasedInvariants<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ALIASES, string>;
+export {};

package/dist/domain/core/invariant/custom-invariants.js

@@ -0,0 +1 @@
+import{withProfilerLabel as t}from"../../utils/profiler-label.js";export const createCustomInvariantFactory=()=>e=>r=>{let n={};return Object.entries(r).forEach(([r,o])=>{let a=Object.entries(o).map(([n,o])=>({evaluate:t(`${r}_invariant_${n}`,(t,a,i)=>{let l=o(i.domain.get$Entity(t,a),a,i);if("boolean"==typeof l){let t=e[r]?.[n];if(!t)throw Error(`Cannot find statically defined violation for ${r}.${n}`);return l?[]:[t]}return l})}));n[r]=a}),n};

package/dist/domain/core/invariant/index.d.ts

@@ -0,0 +1,5 @@
+export * from './builtin-invariant.js';
+export * from './custom-invariants.js';
+export type * from './invariants.js';
+export * from './violation-component.js';
+export * from './violation.js';

package/dist/domain/core/invariant/index.js

@@ -0,0 +1 @@
+export*from"./builtin-invariant.js";export*from"./custom-invariants.js";export*from"./violation-component.js";export*from"./violation.js";

package/dist/domain/core/invariant/invariants.d.ts

@@ -0,0 +1,10 @@
+import type { OpenExpressionContext } from '../expression/index.js';
+import type { DomainEntity, ExpandAlias, TypeOrAlias } from '../model/index.js';
+import type { DomainState } from '../state/index.js';
+import { type Violation } from './violation.js';
+export interface Invariant<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ENTITY extends ENTITIES, VIOLATION_TYPE extends string, CONTEXT_EXTENSION = unknown> {
+    evaluate(selfId: ENTITY['id'], state: DomainState<ENTITIES>, ctx: OpenExpressionContext<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, CONTEXT_EXTENSION>): ReadonlyArray<Violation<VIOLATION_TYPE>>;
+}
+export type AliasedInvariants<ENTITIES extends DomainEntity<string>, ALLOWED_ROOT_ENTITIES extends ENTITIES, PUBLISHED_DATA extends Record<string, unknown>, SESSION_DATA extends Record<string, unknown>, FRONTEND_DATA extends Record<string, unknown>, ALIASES extends Record<string, ENTITIES>, VIOLATION_TYPES extends string> = {
+    [K in TypeOrAlias<ENTITIES, ALIASES>]?: ReadonlyArray<Invariant<ENTITIES, ALLOWED_ROOT_ENTITIES, PUBLISHED_DATA, SESSION_DATA, FRONTEND_DATA, ExpandAlias<ENTITIES, ALIASES, K>, VIOLATION_TYPES>>;
+};

package/dist/domain/core/invariant/invariants.js

@@ -0,0 +1 @@
+export{};

package/dist/domain/core/invariant/violation-component.js

@@ -0,0 +1 @@
+import{SystemComponentBuilder as o}from"../component/index.js";import{ViolationSchema as t}from"./violation.js";export const violationsComponent=o.component("violations").withState({tsType:"ViolationComponentState",type:"object",properties:{violations:{type:"array",items:t}},required:["violations"],additionalProperties:!1}).build();

package/dist/domain/{invariants → core/invariant}/violation.d.ts

@@ -1,7 +1,7 @@
 import type { I18n } from '@lingui/core';
-import type { Localizable } from '@salsita-ai/common/utils';
-import type { $DomainEntity, DomainEntity, EntityId } from '../core/model.js';
-import type { StateEmission } from '../domain-context/store-system/store-system.js';
+import { type Localizable } from '@salsita-ai/common/utils';
+import type { StateEmission } from '../emission/index.js';
+import type { $DomainEntity, DomainEntity, EntityId } from '../model/index.js';
 /**
  * An **ORDERED** list of violation severities.
  * Do not change the order of the items in this list.
@@ -66,7 +66,55 @@ export declare const ViolationSchema: {
             readonly enum: ("fatal" | "fixable" | "notice" | "warning")[];
         };
         readonly message: {
-            readonly type: 'string';
+            readonly anyOf: [{
+                readonly type: 'string';
+            }, {
+                readonly type: 'object';
+                readonly properties: {
+                    readonly id: {
+                        readonly type: 'string';
+                    };
+                    readonly comment: {
+                        readonly type: 'string';
+                    };
+                    readonly message: {
+                        readonly type: 'string';
+                    };
+                    readonly values: {
+                        readonly type: 'object';
+                        readonly additionalProperties: true;
+                    };
+                };
+                readonly required: ["id"];
+                readonly additionalProperties: false;
+                readonly import: [{
+                    readonly module: '@lingui/core';
+                    readonly member: 'MessageDescriptor';
+                }];
+                readonly tsType: 'MessageDescriptor';
+            }, {
+                readonly import: [{
+                    readonly module: '@salsita-ai/sdk/common/utils';
+                    readonly member: 'MultilingualString';
+                }];
+                readonly tsType: 'MultilingualString';
+                readonly type: 'object';
+                readonly properties: {
+                    readonly $lang: {
+                        readonly type: 'object';
+                        readonly additionalProperties: {
+                            readonly type: 'string';
+                        };
+                    };
+                };
+                readonly required: ["$lang"];
+                readonly additionalProperties: false;
+            }];
+            readonly tsType: 'Localizable';
+            readonly import: [{
+                readonly module: '@salsita-ai/sdk/common/utils';
+                readonly member: 'Localizable';
+            }];
         };
         readonly controlViolationPriority: {
             readonly type: 'number';

package/dist/domain/core/invariant/violation.js

@@ -0,0 +1 @@
+import{MessageDescriptorSchema as e,MultilingualStringSchema as t}from"@salsita-ai/common/utils";let i=["fatal","fixable","warning","notice"];export const compareSeverity=(e,t)=>i.indexOf(e)-i.indexOf(t);export const ViolationSchema={type:"object",properties:{type:{type:"string"},severity:{enum:i.slice()},message:{anyOf:[{type:"string"},e,t],tsType:"Localizable",import:[{module:"@salsita-ai/sdk/common/utils",member:"Localizable"}]},controlViolationPriority:{type:"number"}},required:["type","severity"],additionalProperties:!1};

package/dist/domain/core/{component.d.ts → model/component.d.ts}

@@ -1,6 +1,6 @@
 import { type ExtendedJsonSchema } from '@salsita-ai/common/utils';
+import type { PhxValidateFunction } from '../schema/index.js';
 import type { EntityId } from './model.js';
-import type { PhxValidateFunction } from './schema-validator.js';
 /**
  * Definition of how the component looks like, it's name, state and other properties. It is used to instantiate components.
  */

package/dist/domain/core/model/index.d.ts

@@ -0,0 +1,6 @@
+export * from './alias.js';
+export * from './common-definitions.js';
+export * from './component.js';
+export * from './model.js';
+export * from './preset.js';
+export * from './reflection.js';

package/dist/domain/core/model/index.js

@@ -0,0 +1 @@
+export*from"./alias.js";export*from"./common-definitions.js";export*from"./component.js";export*from"./model.js";export*from"./preset.js";export*from"./reflection.js";

package/dist/domain/core/{model.d.ts → model/model.d.ts}

@@ -25,7 +25,7 @@ export declare const VirtualEntityIdSchema: {
 };
 export declare const createVirtualEntityId: (name: string) => VirtualEntityId;
 export declare const isVirtualEntityId: (value: EntityId<any>) => value is VirtualEntityId;
-export type DomainEntityId<TYPE extends string> = `${TYPE}-${number}` & {
+export type DomainEntityId<TYPE extends string = string> = `${TYPE}-${number}` & {
     __brand: TYPE;
 };
 /**

package/dist/domain/core/{reflection.d.ts → model/reflection.d.ts}

@@ -1,6 +1,6 @@
 import type { ExtendedJsonSchema } from '@salsita-ai/common/utils';
+import { type PhxValidateFunction } from '../schema/index.js';
 import { type $DomainEntity, type DomainEntity, type EntityByType, type EntityId } from './model.js';
-import type { PhxValidateFunction } from './schema-validator.js';
 type RequiredKeys<T> = {
     [K in keyof T]: undefined extends T[K] ? never : K;
 }[keyof T];

package/dist/domain/core/model/reflection.js

@@ -0,0 +1 @@
+import{extendedSchemaValidator as t}from"../schema/index.js";import{domainEntityTypeFromId as e,isDomainEntityId as s}from"./model.js";export class SchemaReflection{_meta;constructor(e,s){this._meta={name:e,schema:s,validator:t.compile(s)}}is=t=>this._meta.validator(t);assert(t){if(!this._meta.validator(t))throw Error(`Expected value to match schema of '${this._meta.name}' but got ${t}`)}}export class EnumReflection extends SchemaReflection{constructor(t,e){for(let s of(super(t,e),e.enum))Object.defineProperty(this,s,{value:s,writable:!1,enumerable:!0,configurable:!1})}values=()=>this._meta.schema.enum}let o=class BaseDomainEntityReflection{type;constructor(t){this.type=t}is=t=>t.type===this.type;assert(t){if(!this.is(t))throw Error(`Expected entity #${t.id} to be of type ${this.type} but got ${t.type}`)}isId=t=>s(t)&&e(t)===this.type;assertId(t){if(!this.isId(t))throw Error(`Expected entity id to be of type ${this.type} but got ${t}`)}assertIds(t){t.forEach(t=>{this.assertId(t)})}};export class DomainEntityReflection extends o{_meta;constructor(e,s){super(e);let o=s.reduce((t,e)=>{let s=e.$defs;return"object"==typeof s&&null!==s&&Object.assign(t,s),t},{}),r={type:"object",properties:{id:{type:"string",pattern:`^${e}-[0-9]+$`},type:{type:"string",const:e},...s.reduce((t,e)=>({...t,...e.properties}),{})},required:["id","type",...s.flatMap(t=>t.required??[])],additionalProperties:!1},i={...r,$defs:o};this._meta={name:e,schema:r,validator:t.compile(i)}}}let r=class $DomainEntityReflectionClass extends o{expressions;constructor(t,e,s){super(t),this.expressions=e,Object.assign(this,s)}};export const $DomainEntityReflection=r;let i=class BaseAliasReflection{name;types;typeSet;constructor(t,e){this.name=t,this.types=e,this.typeSet=new Set(e)}is=t=>this.typeSet.has(t.type);assert(t){if(!this.is(t))throw Error(`Expected entity #${t.id} to be a member of alias ${this.name} but got ${t.type}`)}isId=t=>s(t)&&this.typeSet.has(e(t));assertId(t){if(!this.isId(t))throw Error(`Expected entity id to be of a member of alias ${this.name} but got ${t}`)}assertIds(t){t.forEach(t=>{this.assertId(t)})}};export class RawAliasReflection extends i{reflections;constructor(t,e){super(t,e.map(t=>t.type)),this.reflections=e}}let a=class EnhancedAliasReflectionClass extends i{constructor(t,e,s){super(t,e),Object.assign(this,s)}};export const EnhancedAliasReflection=a;export function assertString(t){if("string"!=typeof t)throw Error(`Expected value to be a string but got ${t}`)}export function assertNumber(t){if("number"!=typeof t)throw Error(`Expected value to be a number but got ${t}`)}export function assertBoolean(t){if("boolean"!=typeof t)throw Error(`Expected value to be a boolean but got ${t}`)}

package/dist/domain/core/recipe/index.d.ts

@@ -0,0 +1 @@
+export * from './recipes.js';