@acorex-platform/module-data-management-client 0.0.21

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@acorex-platform/module-data-management-client",
+  "version": "0.0.21",
+  "sideEffects": false,
+  "peerDependencies": {
+    "@angular/common": "^21.0.0",
+    "@angular/core": "^21.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/acorex-platform-module-data-management-client.mjs",
+  "typings": "types/acorex-platform-module-data-management-client.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/acorex-platform-module-data-management-client.d.ts",
+      "default": "./fesm2022/acorex-platform-module-data-management-client.mjs"
+    },
+    "./contracts": {
+      "types": "./types/acorex-platform-module-data-management-client-contracts.d.ts",
+      "default": "./fesm2022/acorex-platform-module-data-management-client-contracts.mjs"
+    }
+  },
+  "type": "module"
+}

package/types/acorex-platform-module-data-management-client-contracts.d.ts

@@ -0,0 +1,429 @@
+import { AXPMultiLanguageString, AXPOptionsData, AXPMetaDataDefinition, AXPFilterDefinition, AXPCategoryListItem } from '@acorex-platform/framework-shared/core';
+import { AXPEntityModel } from '@acorex-platform/framework-shared/entity';
+
+declare const AXM_COLUMN_DEF_WIDGET: {
+    type: string;
+    mode: string;
+    options: {
+        direction: string;
+    };
+    children: ({
+        type: string;
+        mode: string;
+        options: {
+            colSpan: number;
+        };
+        children: {
+            type: string;
+            mode: string;
+            path: string;
+            options: {
+                placeholder: string;
+                required: boolean;
+            };
+        }[];
+    } | {
+        type: string;
+        options: {
+            colSpan: number;
+        };
+        mode: string;
+        children: {
+            type: string;
+            mode: string;
+            path: string;
+            options: {
+                placeholder: string;
+                valueField: string;
+                textField: string;
+                dataSource: string;
+                direction: string;
+                multiple: boolean;
+                required: boolean;
+            };
+        }[];
+    } | {
+        type: string;
+        options: {
+            colSpan: number;
+        };
+        mode: string;
+        children: {
+            type: string;
+            mode: string;
+            path: string;
+            options: {
+                tooltip: string;
+                label: string;
+            };
+            triggers: {
+                event: string;
+                action: string;
+            }[];
+        }[];
+    } | {
+        type: string;
+        options: {
+            colSpan: number;
+        };
+        mode: string;
+        children: {
+            type: string;
+            mode: string;
+            path: string;
+            options: {
+                tooltip: string;
+                label: string;
+            };
+        }[];
+    })[];
+}[];
+
+declare const AXMDataManagementFeatureKeys: {
+    readonly Queries: "DataManagement:Feature:Queries";
+    readonly DataSources: "DataManagement:Feature:DataSources";
+    readonly MetaDataDefinitions: "DataManagement:Feature:MetaDataDefinitions";
+};
+
+declare const AXPDataManagementMenuKeys: {
+    readonly Root: "DataManagement:Menu";
+    readonly Queries: "DataManagement:Menu:Queries";
+    readonly DataSources: "DataManagement:Menu:DataSources";
+    readonly MetaDataDefinitions: "DataManagement:Menu:MetaDataDefinitions";
+    readonly Tags: "DataManagement:Menu:Tags";
+};
+
+/** Localized or plain string as stored / edited in the builder */
+type AXMMetaDataLocalizedString = string | AXPMultiLanguageString;
+/** Single metadata field within a group */
+interface AXMMetaDataBuilderField {
+    id: string;
+    name: string;
+    title: AXMMetaDataLocalizedString;
+    description?: AXMMetaDataLocalizedString;
+    interface: string;
+    configuration?: {
+        isRequired?: boolean;
+        placeholder?: string;
+        [key: string]: unknown;
+    };
+    status: 'active' | 'deleted' | 'temporary';
+    order: number;
+    isNewlyAdded?: boolean;
+}
+/** Group of metadata fields */
+interface AXMMetaDataBuilderGroup {
+    id: string;
+    name: string;
+    title?: AXMMetaDataLocalizedString;
+    description?: AXMMetaDataLocalizedString;
+    order: number;
+    fields: AXMMetaDataBuilderField[];
+    isNewlyAdded?: boolean;
+}
+/** Designer state (internal) */
+interface AXMMetaDataBuilderState {
+    groups: AXMMetaDataBuilderGroup[];
+    mode: 'designer' | 'preview';
+    selectedFieldId?: string;
+    selectedGroupId?: string;
+}
+/** Value persisted on the entity */
+interface AXMMetaDataBuilderValue {
+    groups: Array<{
+        name: string;
+        title?: AXMMetaDataLocalizedString;
+        description?: AXMMetaDataLocalizedString;
+        order: number;
+        fields: Array<{
+            id: string;
+            name: string;
+            title: AXMMetaDataLocalizedString;
+            description?: AXMMetaDataLocalizedString;
+            interface: string;
+            configuration?: AXPOptionsData;
+            order: number;
+        }>;
+    }>;
+}
+declare function convertValueToState(value: unknown): AXMMetaDataBuilderState;
+declare function convertStateToValue(state: AXMMetaDataBuilderState): AXMMetaDataBuilderValue;
+declare function createDefaultGroup(): AXMMetaDataBuilderGroup;
+
+/**
+ * Insights & Reporting capabilities used by this module.
+ * Domain capability keys for this module. Root groups live in `AXPCommonPermissionGroupKeys` (common contracts).
+ */
+declare const AXPInsightsReportingPermissionKeys: {
+    readonly Access: "InsightsReporting:Permission:Access";
+    readonly MaintainReports: "InsightsReporting:Permission:MaintainReports";
+    readonly MaintainData: "InsightsReporting:Permission:MaintainData";
+    readonly ViewActivityInsight: "InsightsReporting:Permission:ViewActivityInsight";
+    readonly ManageActivityInsight: "InsightsReporting:Permission:ManageActivityInsight";
+    readonly Setup: "InsightsReporting:Permission:Setup";
+};
+/**
+ * @deprecated Prefer {@link AXPInsightsReportingPermissionKeys}.
+ * Legacy nested shape kept so existing imports compile during migration.
+ */
+declare const AXMPermissionsKeys: {
+    readonly DataManagement: {
+        readonly Query: {
+            readonly Management: "InsightsReporting:Permission:MaintainData";
+        };
+        readonly DataSource: {
+            readonly Management: "InsightsReporting:Permission:MaintainData";
+        };
+        readonly MetaDataDefinition: {
+            readonly Management: "InsightsReporting:Permission:Setup";
+        };
+        readonly Equipment: {
+            readonly Management: "InsightsReporting:Permission:MaintainData";
+        };
+        readonly Tag: {
+            readonly Management: "InsightsReporting:Permission:Setup";
+        };
+    };
+};
+
+declare const RootConfig: {
+    readonly config: {
+        i18n: string;
+    };
+    readonly module: {
+        readonly route: "data-management";
+        readonly name: "DataManagement";
+        readonly title: "@data-management:module.title";
+        readonly icon: "fa-regular fa-database";
+    };
+    readonly entities: {
+        readonly query: {
+            readonly name: "Query";
+            readonly title: "@data-management:queries.entities.query.title";
+            readonly titlePlural: "@data-management:queries.entities.query.plural";
+            readonly icon: "fa-regular fa-nfc-magnifying-glass";
+        };
+        readonly queryCategory: {
+            readonly name: "QueryCategory";
+            readonly title: "@data-management:queries.terms.category";
+            readonly titlePlural: "@data-management:queries.terms.categories";
+            readonly icon: "fa-regular fa-layer-group";
+        };
+        readonly dataSource: {
+            readonly name: "DataSource";
+            readonly title: "@data-management:data-sources.entities.data-source.title";
+            readonly titlePlural: "@data-management:data-sources.entities.data-source.plural";
+            readonly icon: "fa-regular fa-database";
+        };
+        readonly dataSourceCategory: {
+            readonly name: "DataSourceCategory";
+            readonly title: "@data-management:data-sources.terms.category";
+            readonly titlePlural: "@data-management:data-sources.terms.categories";
+            readonly icon: "fa-regular fa-layer-group";
+        };
+        readonly metaDataDefinition: {
+            readonly name: "MetaDataDefinition";
+            readonly title: "@data-management:metadata-definitions.entities.metadata-definition.title";
+            readonly titlePlural: "@data-management:metadata-definitions.entities.metadata-definition.plural";
+            readonly icon: "fa-light fa-server";
+        };
+        readonly tag: {
+            readonly name: "Tag";
+            readonly source: "DataManagement.Tag";
+            readonly title: "@general:terms.common.tag";
+            readonly icon: "fa-light fa-tags";
+        };
+        readonly equipmentCategory: {
+            readonly name: "EquipmentCategory";
+            readonly title: "@data-management:equipments.entities.equipment-category.title";
+            readonly titlePlural: "@data-management:equipments.entities.equipment-category.plural";
+            readonly icon: "fa-light fa-folder-tree";
+        };
+        readonly equipment: {
+            readonly name: "Equipment";
+            readonly source: "DataManagement.Equipment";
+            readonly title: "@data-management:equipments.entities.equipment.title";
+            readonly titlePlural: "@data-management:equipments.entities.equipment.plural";
+            readonly icon: "fa-light fa-plug";
+        };
+    };
+};
+
+declare enum AXMDataSourceOutputType {
+    Table = "table",
+    SingleObject = "single_object",
+    Value = "value"
+}
+interface AXMDataSourceOutputTypeOption {
+    name: AXMDataSourceOutputType;
+    title: string;
+}
+declare enum AXMDataSourceType {
+    Static = "static",
+    Query = "query"
+}
+interface AXMDataSourceTypeOption {
+    name: AXMDataSourceType;
+    title: string;
+}
+interface AXMDataSourceFilter {
+    columnName: string;
+    defaultValue: any;
+    isSystemFilter: boolean;
+    isRequired: boolean;
+}
+interface AXMDataSourceEntityModel<T = string> extends AXPEntityModel<T> {
+    name: string;
+    title: string;
+    categoryIds?: string[];
+    sourceStatic: any[];
+    sourceEntity: T;
+    sourceType: AXMDataSourceTypeOption;
+    outputType: AXMDataSourceOutputTypeOption;
+    filters?: AXMDataSourceFilter[];
+}
+
+interface AXMMetaDataDefinitionEntityModel<T = string> extends AXPEntityModel<T>, AXPMetaDataDefinition {
+    /** Optional entity field (may be localized like `title`). */
+    description?: string | AXPMultiLanguageString;
+}
+
+/**
+ * Query output type
+ * Defines the expected structure of the query result
+ */
+type AXPQueryOutputType = 'value' | 'table' | 'object';
+/**
+ * Sort rule for query builder
+ */
+interface AXPQuerySortRule {
+    field: string;
+    dir: 'asc' | 'desc';
+}
+/**
+ * Aggregate operation in query
+ * Represents an aggregate function applied to a field
+ * Supports nested aggregates (e.g., CONCAT(MIN(field1), MAX(field2)))
+ */
+interface AXPAggregateOperation {
+    /**
+     * Field name to aggregate (optional if nestedAggregates is provided)
+     */
+    field?: string;
+    /**
+     * Aggregate function name
+     */
+    function: string;
+    /**
+     * Output alias/name for the aggregated result
+     */
+    alias?: string;
+    /**
+     * Whether to use DISTINCT modifier
+     */
+    distinct?: boolean;
+    /**
+     * Nested aggregate operations (for functions like CONCAT that can contain other aggregates)
+     * Example: CONCAT(MIN(price), MAX(price)) would have:
+     * - function: 'concat'
+     * - nestedAggregates: [
+     *     { function: 'min', field: 'price' },
+     *     { function: 'max', field: 'price' }
+     *   ]
+     */
+    nestedAggregates?: AXPAggregateOperation[];
+}
+/**
+ * Complete query builder data model
+ * Includes all query components: dataSource, columns, where, sort, groupBy, aggregates, and raw query
+ */
+interface AXPQueryBuilderData {
+    /**
+     * Data source name (optional, can be set from context)
+     */
+    dataSource?: string;
+    /**
+     * Selected column names (array of column keys)
+     */
+    columns: string[];
+    /**
+     * WHERE clause (filter definition with groups and conditions)
+     */
+    where: AXPFilterDefinition;
+    /**
+     * Sort rules (array of field + direction)
+     */
+    sort: AXPQuerySortRule[];
+    /**
+     * Group by columns (array of column keys)
+     */
+    groupBy: string[];
+    /**
+     * Aggregate operations (array of field + function + alias)
+     */
+    aggregates: AXPAggregateOperation[];
+    /**
+     * Raw SQL/query string (optional, used when user wants to write raw query)
+     */
+    rawQuery?: string;
+    /**
+     * Query language/dialect for raw query (e.g., 'mysql', 'postgresql', 'mongodb')
+     */
+    queryLanguage?: string;
+    /**
+     * Expected output type for the query result
+     * - 'value': Single value result (e.g., COUNT, SUM, AVG)
+     * - 'table': Table result with items array and total
+     * - 'object': Custom object structure
+     */
+    outputType?: AXPQueryOutputType;
+}
+/**
+ * Query execution result
+ * Can be:
+ * - A single value (for aggregate queries like SUM, COUNT, etc.)
+ * - A table with items and total (for regular queries)
+ * - An object with custom structure
+ */
+type AXPQueryExecutionResult = {
+    /**
+     * Table result with items array
+     */
+    items: Record<string, unknown>[];
+    total: number;
+    metadata?: Record<string, unknown>;
+} | {
+    /**
+     * Single aggregate value result
+     */
+    value: unknown;
+    metadata?: Record<string, unknown>;
+} | Record<string, unknown> | unknown[];
+interface AXMDataManagementQueryEntityModel extends AXPEntityModel<string> {
+    name: string;
+    title: string;
+    dataSource?: AXMDataSourceEntityModel;
+    query?: AXPQueryBuilderData;
+    categoryIds?: string[];
+    categories?: AXPCategoryListItem[];
+}
+type AXMQueryEntityModel = AXMDataManagementQueryEntityModel;
+
+/**
+ * Tag entity model
+ */
+interface AXMTag {
+    id: string;
+    text: string;
+    color: string;
+    icon?: string;
+    description?: string;
+    scope: 'system' | 'tenant' | 'user';
+    isReadonly?: boolean;
+    createdBy?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+export { AXMDataManagementFeatureKeys, AXMDataSourceOutputType, AXMDataSourceType, AXMPermissionsKeys, AXM_COLUMN_DEF_WIDGET, AXPDataManagementMenuKeys, AXPInsightsReportingPermissionKeys, RootConfig, convertStateToValue, convertValueToState, createDefaultGroup };
+export type { AXMDataManagementQueryEntityModel, AXMDataSourceEntityModel, AXMDataSourceFilter, AXMDataSourceOutputTypeOption, AXMDataSourceTypeOption, AXMMetaDataBuilderField, AXMMetaDataBuilderGroup, AXMMetaDataBuilderState, AXMMetaDataBuilderValue, AXMMetaDataDefinitionEntityModel, AXMMetaDataLocalizedString, AXMQueryEntityModel, AXMTag, AXPAggregateOperation, AXPQueryBuilderData, AXPQueryExecutionResult, AXPQueryOutputType, AXPQuerySortRule };