@acorex/platform 21.0.0-next.85 → 21.0.0-next.89

package/types/acorex-platform-domain-contracts.d.ts

@@ -0,0 +1,416 @@
+import { AXPExpression, AXPOptionsData, AXPDataType, AXPMetaData, AXPValidationRules, AXPDefinitionCategory } from '@acorex/platform/contracts';
+
+declare enum AXPDomainActionSide {
+    Client = "client",
+    Server = "server",
+    Both = "both"
+}
+/**
+ * Interface for defining actions
+ */
+interface AXPDomainAction {
+    event: string;
+    side: 'client' | 'server' | 'both';
+    condition?: AXPExpression;
+    expression: AXPExpression;
+}
+declare enum AXPEntityCommandScope {
+    TypeLevel = "typeLevel",
+    Selected = "selected",
+    Individual = "individual",
+    Section = "section"
+}
+interface AXPDomainRealtedModuleEntity {
+    moduleId?: string;
+    module?: {
+        id?: string;
+        name?: string;
+        title?: string;
+    };
+    entityId?: string;
+    entity?: {
+        id?: string;
+        name?: string;
+        title?: string;
+    };
+}
+
+/** Widget category for interface grouping (e.g. Editors, Layout, Action). */
+interface AXPInterfaceCategory {
+    name: string;
+    title: string;
+    order?: number;
+}
+/** Widget interface definition stored in DB (display metadata + option definitions). Values are stored in schema. */
+interface AXPInterfaceDefinition {
+    name: string;
+    title?: string;
+    description?: string;
+    icon?: string;
+    dataType?: AXPDataType;
+    /** Widget categories (e.g. Editors, Layout). */
+    categories?: AXPInterfaceCategory | AXPInterfaceCategory[];
+    /** Widget groups (e.g. form-element, entity-widget). */
+    groups?: string[];
+    /** Widget type: editor, view, filter, container, action, etc. */
+    type?: string;
+    /** Default filter widget name when used as filter (e.g. string-filter, number-filter). */
+    defaultFilterWidgetName?: string;
+    optionDefinitions?: AXPPropertyDefinition[];
+}
+interface AXPInterfaceDefinitionValue {
+    name: string;
+    title: string;
+    options?: AXPOptionsData;
+}
+
+/**
+ * Where the validation rule runs: client-side only, server-side only, or both.
+ */
+type AXPValidationRunAt = 'client' | 'server' | 'both';
+/**
+ * Validation rule definition (catalog model): metadata for available validation rules.
+ * Used in UI to list validation rules: name (rule key), title, description, and runAt.
+ * The actual rule usage on properties uses AXPValidationRule from @acorex/platform/core.
+ */
+interface AXPValidationRuleDefinition extends AXPDomainRealtedModuleEntity {
+    rule: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    /** Where the validation runs: client-side, server-side, or both. Default: 'client' */
+    runAt?: AXPValidationRunAt;
+    message?: string;
+    options?: AXPPropertyDefinition[];
+}
+interface AXPValidationRuleValue {
+    rule: string;
+    title?: string;
+    message?: string;
+    options?: AXPMetaData;
+}
+
+interface AXPPropertyFeatures {
+    searchable?: {
+        enabled: boolean;
+        fullText: boolean;
+    };
+    filterable?: {
+        enabled: boolean;
+        inline: boolean;
+    };
+    sortable?: {
+        enabled: boolean;
+    };
+    auditable?: {
+        enabled: boolean;
+    };
+}
+interface AXPPropertyDefinition {
+    name: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    defaultValue?: unknown;
+    disabled?: boolean;
+    dataType?: AXPDataType;
+    interface: AXPInterfaceDefinitionValue;
+    validations?: AXPValidationRuleValue[];
+    features?: AXPPropertyFeatures;
+    metadata?: AXPMetaData;
+}
+
+/**
+ * Plugin definition (catalog model): metadata for available plugins.
+ * Used in UI to list plugins: name, title, optional icon, description, and options schema.
+ */
+interface AXPPluginDefinition extends AXPDomainRealtedModuleEntity {
+    name: string;
+    title: string;
+    description?: string;
+    icon?: string;
+    options?: AXPPropertyDefinition[];
+}
+/**
+ * Plugin value in entity: name + optional options (key-value).
+ * Fills the definition when used on an entity.
+ */
+interface AXPPluginDefinitionValue {
+    name: string;
+    options?: AXPMetaData;
+}
+
+declare enum AXPEntityType {
+    Entity = 0,
+    AggregateRoot = 1,
+    ValueObject = 2
+}
+interface AXPEntityDefinition {
+    name: string;
+    title: string;
+    fields: AXPEntityPropertyDefinition[];
+    type: AXPEntityType;
+    /** Entity plugins (e.g. common.history, common.lock). Name + optional options only. */
+    plugins?: AXPPluginDefinitionValue[];
+    /** Property groups for layout */
+    groups?: Array<{
+        id: string;
+        title: string;
+    }>;
+    /** List/table columns */
+    columns?: Array<{
+        name: string;
+    }>;
+    /** Display formats */
+    formats?: {
+        individual?: string;
+        plural?: string;
+    };
+    /** Layout interfaces (master create/update/single/list). Pass-through for converter. */
+    interfaces?: Record<string, unknown>;
+    /** Module name (e.g. ContentManagement). Derived from path or explicit. */
+    module?: string;
+    /** Entity icon. */
+    icon?: string;
+}
+interface AXPEntityPropertyFeatures {
+    nullable: boolean;
+    readOnly: boolean;
+}
+/**
+ * Entity field: flattened embedded property definition (interface, validations, features) plus entity-only metadata.
+ * Top-level name/title are the entity property name/title.
+ */
+interface AXPEntityPropertyDefinition extends AXPPropertyDefinition {
+    actions?: AXPDomainAction[];
+    /** Nullable/readOnly for entity binding; distinct from property.features (searchable, filterable, etc.). */
+    fieldFeatures?: AXPEntityPropertyFeatures;
+}
+
+type AXPAggregateEntityList = {
+    [key: string]: () => Promise<AXPEntityDefinition>;
+};
+/**
+ * Aggregate definition. Relations are stored in a separate collection (like MySQL join table).
+ * Join when needed via relations collection.
+ */
+interface AXPAggregateDefinition {
+    name: string;
+    title: string;
+    entities: AXPEntityDefinition[] | AXPAggregateEntityList | Record<string, string>;
+    validations: AXPValidationRules;
+    actions: AXPDomainAction[];
+}
+
+interface AXPModuleDefinition {
+    name: string;
+    title: string;
+    aggregates: AXPAggregateDefinition[];
+}
+
+declare enum AXPRelationshipKind {
+    Association = 0,
+    Composition = 1,
+    Aggregation = 2
+}
+declare enum AXPRelationshipCardinality {
+    OneToOne = 0,
+    OneToMany = 1,
+    ManyToMany = 2
+}
+/**
+ * Standalone relation definition with full source and target.
+ * Relations live in their own collection, independent of aggregates.
+ */
+interface AXPRelationDefinition {
+    id?: string;
+    type: AXPRelationshipCardinality;
+    kind: AXPRelationshipKind;
+    source: {
+        aggregate: string;
+        entity: string;
+        key: string;
+    };
+    target: {
+        aggregate: string;
+        entity: string;
+        key: string;
+    };
+    isRequired: boolean;
+}
+
+/**
+ * Discriminated JSON for `AXPMenuDefinitionRecord.command`.
+ * Modal navigation is omitted (Angular `Type` is not JSON-serializable).
+ */
+type AXPMenuDefinitionStoredCommand = {
+    kind: 'navigate';
+    navigateType: 'router';
+    path: string;
+    extras?: Record<string, unknown>;
+} | {
+    kind: 'execute';
+    name: string;
+    options?: Record<string, unknown>;
+};
+/**
+ * Optional reference to an entity list route: resolved at runtime via `AXPEntityService.createPath`.
+ */
+interface AXPMenuDefinitionEntityListRef {
+    module: string;
+    entity: string;
+}
+/**
+ * Serializable menu definition for definition stores (Dexie/Firestore in mock today).
+ * Mirrors persisted shape for `AXPEntityDefinitionCrudService` menu APIs — not identical to shell `AXPMenuItem`.
+ */
+interface AXPMenuDefinitionRecord {
+    /** Same as `AXPMenuItem.name` (unique key). */
+    name: string;
+    text: string;
+    description?: string;
+    icon?: string;
+    priority?: number;
+    type?: 'menu' | 'group' | 'break';
+    /**
+     * Parent menu `name` for `context.find(attachParentName).addItems(...)`.
+     * Empty omits attachment (provider may add to root — see implementation).
+     */
+    attachParentName?: string;
+    /** Literal router path; if both this and `entityListRef` are set, implementations may prefer this. */
+    path?: string;
+    entityListRef?: AXPMenuDefinitionEntityListRef;
+    policyFeatures?: string[];
+    policyPermissions?: string[];
+    badgeKey?: string;
+    command?: AXPMenuDefinitionStoredCommand;
+    /**
+     * Optional module classification (references `PlatformManagement.ModuleDefinitions` when using the category plugin).
+     */
+    categoryIds?: string[];
+    /** Denormalized labels for list/display (mirrors product category pattern). */
+    categories?: Array<{
+        id: string;
+        title?: string;
+    }>;
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * One level of child permissions under a root permission (fluent `addChild` only).
+ * Nested `children` under leaves are not part of the storage contract.
+ */
+interface AXPPermissionLeafRecord {
+    name: string;
+    title: string;
+    description?: string;
+    requiredFeatures?: string[];
+}
+/**
+ * Root permission row: one `addPermission` … `endPermission` chain, with optional sibling `addChild` entries.
+ */
+interface AXPPermissionDefinitionRecord {
+    name: string;
+    title: string;
+    description?: string;
+    requiredFeatures?: string[];
+    /** At most one level — matches `AXPPermissionDefinitionProviderContext` fluent API. */
+    children?: AXPPermissionLeafRecord[];
+}
+/**
+ * Serializable permission group for definition stores (Dexie/Firestore).
+ * Aligns with `AXPPermissionGroupDefinition` / fluent providers; one row per group.
+ */
+interface AXPPermissionGroupDefinitionRecord {
+    name: string;
+    title: string;
+    description?: string;
+    permissions: AXPPermissionDefinitionRecord[];
+    /**
+     * Optional module classification (references `PlatformManagement.ModuleDefinitions` when using the category plugin).
+     */
+    categoryIds?: string[];
+    /** Denormalized labels for list/display (mirrors product category pattern). */
+    categories?: Array<{
+        id: string;
+        title?: string;
+    }>;
+}
+
+/** Surfaces where a command may be exposed (tooling / automation). Build-time: optional on `defineCommand`. */
+type AXPCommandCapability = 'ai' | 'workflow';
+/**
+ * Persisted command registry row (e.g. Dexie/Firestore via AXPEntityDefinitionCrudService).
+ * `name` is the runtime command key; `active` is the toggle stored for mock/admin UIs.
+ */
+interface AXPCommandRegistryRecord {
+    name: string;
+    active: boolean;
+    /** Human / AI-oriented description of what the command does. */
+    description?: string;
+    /** Input parameters as schema rows (same shape as interface `optionDefinitions`). */
+    inputOptionDefinitions?: AXPPropertyDefinition[];
+    /** Output shape as schema rows (same shape as interface `optionDefinitions`). */
+    outputOptionDefinitions?: AXPPropertyDefinition[];
+    /** Display title from build-time command metadata (`*.definition.ts`). */
+    catalogTitle?: string;
+    /** Where the command runs (metadata). */
+    executionMode?: 'frontend' | 'backend' | 'both';
+    /** Pretty-printed JSON of the outcomes definition from metadata (readonly display). */
+    outcomesDefinitionJson?: string;
+    /** Pretty-printed JSON of AI hints from metadata (readonly display). */
+    aiMetadataJson?: string;
+    /**
+     * Optional capability flags (from build-time `capabilities` on command metadata).
+     * Omitted or empty means no declared surface; consumers may still apply legacy rules (e.g. AI `ai-tool` tag).
+     */
+    capabilities?: AXPCommandCapability[];
+    /** Optional grouping from build-time command metadata (`categories` on `defineCommand`). */
+    categories?: AXPDefinitionCategory[];
+}
+
+/**
+ * Persisted query registry row (e.g. Dexie/Firestore via AXPEntityDefinitionCrudService).
+ * `name` is the runtime query key; `active` is the toggle stored for mock/admin UIs.
+ * Queries expose `fetch(input)` only — no command outcomes.
+ */
+interface AXPQueryRegistryRecord {
+    name: string;
+    active: boolean;
+    /** Human / AI-oriented description of what the query returns. */
+    description?: string;
+    /** Input parameters (filter / criteria) as property definition rows. */
+    inputOptionDefinitions?: AXPPropertyDefinition[];
+    /** Result shape as property definition rows (documentation / tooling). */
+    outputOptionDefinitions?: AXPPropertyDefinition[];
+    /** Display title from build-time query metadata (`*.query.definition.ts`). */
+    catalogTitle?: string;
+    /** Where the query runs (metadata). */
+    executionMode?: 'frontend' | 'backend' | 'both';
+    /** Pretty-printed JSON of AI hints from metadata (readonly display). */
+    aiMetadataJson?: string;
+    /**
+     * Optional capability flags (from build-time `capabilities` on query metadata).
+     * Omitted or empty means no declared surface; consumers may still apply legacy rules (e.g. AI `ai-tool` tag).
+     */
+    capabilities?: AXPCommandCapability[];
+    /** Optional grouping from build-time query metadata (`categories` on `defineQuery`). */
+    categories?: AXPDefinitionCategory[];
+}
+
+/**
+ * Persisted layout-widget catalog row (Dexie/Firestore via AXPEntityDefinitionCrudService).
+ * `name` is the widget registry name from build-time `defineWidget` metadata; `metadataJson` holds the full payload.
+ */
+interface AXPWidgetCatalogRecord {
+    name: string;
+    active: boolean;
+    description?: string;
+    /** Localized / catalog title from metadata `title`. */
+    catalogTitle?: string;
+    /** Pretty-printed JSON of full widget metadata (`defineWidget` sidecar). */
+    metadataJson?: string;
+}
+
+export { AXPDomainActionSide, AXPEntityCommandScope, AXPEntityType, AXPRelationshipCardinality, AXPRelationshipKind };
+export type { AXPAggregateDefinition, AXPAggregateEntityList, AXPCommandCapability, AXPCommandRegistryRecord, AXPDomainAction, AXPDomainRealtedModuleEntity, AXPEntityDefinition, AXPEntityPropertyDefinition, AXPEntityPropertyFeatures, AXPInterfaceCategory, AXPInterfaceDefinition, AXPInterfaceDefinitionValue, AXPMenuDefinitionEntityListRef, AXPMenuDefinitionRecord, AXPMenuDefinitionStoredCommand, AXPModuleDefinition, AXPPermissionDefinitionRecord, AXPPermissionGroupDefinitionRecord, AXPPermissionLeafRecord, AXPPluginDefinition, AXPPluginDefinitionValue, AXPPropertyDefinition, AXPPropertyFeatures, AXPQueryRegistryRecord, AXPRelationDefinition, AXPValidationRuleDefinition, AXPValidationRuleValue, AXPValidationRunAt, AXPWidgetCatalogRecord };