@dcupl/common 1.11.11 → 2.0.0-beta.0

package/dist/esm/queryData.d.ts

@@ -1,10 +1,14 @@
-import { ListItem, DcuplQueryGroup, InverseIndexReferenceMap, DcuplQueryTransformOptions, CustomOperatorFn } from './types';
+import { ListItem, InverseIndexReferenceMap, DcuplQueryTransformOptions, CustomOperatorFn, DcuplGlobalQueryOptions } from './types';
 import { ScriptController } from './script.controller';
+import { ModelParser } from '@dcupl/core/model-parser';
+import { ItemService } from '@dcupl/core/catalog';
 export declare class QueryManager {
-    private scriptController;
+    scriptController: ScriptController;
+    globalItemService: ItemService;
+    modelParser: ModelParser;
     private registeredCustomOperator;
     private queryBuilder;
-    constructor(scriptController: ScriptController);
+    constructor(scriptController: ScriptController, globalItemService: ItemService, modelParser: ModelParser);
     registerCustomOperator(operator: string, fn: CustomOperatorFn): void;
     transformValue(value: any, transformers: DcuplQueryTransformOptions[]): any;
     private evaluateQuery;
@@ -13,6 +17,7 @@ export declare class QueryManager {
     queryFind(entryValue: any | any[], queryValue: any, arrayValueHandling: 'some' | 'every'): boolean;
     private validateQuery;
     private getEvaluatedQueryDataset;
+    private handleArrayStarQuery;
     private evaluateQueryGroup;
-    queryData<ListType extends ListItem = ListItem>(initialData: Map<string, ListType>, rootQuery: DcuplQueryGroup, earlyReturn: boolean, indexMap: InverseIndexReferenceMap): Map<string, ListType>;
+    queryData<ListType extends ListItem = ListItem>(initialData: Map<string, ListType>, rootQuery: DcuplGlobalQueryOptions<any>, earlyReturn: boolean, indexMap: InverseIndexReferenceMap): Map<string, ListType>;
 }

package/dist/esm/types/dcupl.types.d.ts

@@ -6,6 +6,7 @@ import { DcuplGroupByOptions } from './group-by.types';
 import { DcuplItemsOptions } from './list.types';
 import { DcuplGlobalQueryOptions } from './query.types';
 import { SuggestionOptions } from './suggestion.types';
+import { LogLevel, LogEntry } from '../logger';
 export type DcuplInitOptions = {
     config?: DcuplInitConfig;
     /**
@@ -22,6 +23,10 @@ export type DcuplInitOptions = {
     performance?: DcuplInitPerformanceConfig;
     analytics?: DcuplInitErrorAnalyticsConfig;
     referenceMetadata?: DcuplInitReferenceMetadataConfig;
+    /**
+     * Configure logging behavior
+     */
+    logging?: DcuplInitLoggingConfig;
 };
 export type DcuplInitPerformanceConfig = {
     /**
@@ -38,6 +43,58 @@ export type DcuplInitPerformanceConfig = {
     clone?: {
         enabled: boolean;
     };
+    /**
+     * Configuration for partial update optimization strategy
+     */
+    partialUpdates?: DcuplPartialUpdateConfig;
+    /**
+     * Controls async/sync processing mode for containers:
+     * - undefined (default): Async mode - yield after every container (backward compatible)
+     * - 0: Synchronous mode - never yield (best performance, may block UI)
+     * - N > 0: Batched mode - yield every N containers (balanced performance)
+     *
+     * Note: Synchronous/batched modes are opt-in optimizations. Use only if your
+     * application can handle synchronous processing without UI blocking.
+     */
+    containerBatchSize?: number;
+    /**
+     * Controls whether lists automatically update when affected by data changes.
+     * When enabled, lists automatically call update() when their data changes.
+     * When disabled, manual list.update() calls are required.
+     *
+     * Can be overridden at list-level or per-update.
+     */
+    autoUpdateLists?: {
+        enabled: boolean;
+    };
+};
+/**
+ * Configuration options for partial update optimization
+ */
+export type DcuplPartialUpdateConfig = {
+    /**
+     * Threshold for model ratio (0-1). If more than this percentage of models are affected,
+     * a full update will be triggered instead of a partial update.
+     * Default: 0.5 (50%)
+     */
+    modelRatioThreshold?: number;
+    /**
+     * Threshold for item ratio (0-1). If more than this percentage of items in affected models change,
+     * a full update will be triggered instead of a partial update.
+     * Default: 0.5 (50%)
+     */
+    itemRatioThreshold?: number;
+    /**
+     * Threshold for cache invalidation (0-1). If more than this percentage of models are affected,
+     * the entire cache will be cleared instead of selective invalidation.
+     * Default: 0.7 (70%)
+     */
+    cacheInvalidationThreshold?: number;
+    /**
+     * Enable detailed logging of update decisions and performance metrics
+     * Default: false
+     */
+    enableDetailedLogging?: boolean;
 };
 export type DcuplInitQualityConfig = {
     enabled: boolean;
@@ -51,6 +108,29 @@ export type DcuplInitErrorAnalyticsConfig = {
 export type DcuplInitReferenceMetadataConfig = {
     enabled: boolean;
 };
+export type DcuplInitLoggingConfig = {
+    /**
+     * Minimum log level to output
+     * Default: 'info' in production, 'debug' in development
+     */
+    level?: LogLevel;
+    /**
+     * Output format
+     * - 'json': Structured logs for production/cloud platforms (AWS, Azure, etc.)
+     * - 'pretty': Human-readable logs with colors/icons for development
+     * Default: 'json' in production, 'pretty' in development
+     */
+    format?: 'json' | 'pretty';
+    /**
+     * Custom log handler for sending logs to external services
+     */
+    onLog?: (entry: LogEntry) => void;
+    /**
+     * Module-specific log levels
+     * @example { 'ModelParser': 'debug', 'Catalog': 'warn' }
+     */
+    modules?: Record<string, LogLevel>;
+};
 export type DcuplInitConfig = {
     /**
      * The project id optained from the dcupl console

package/dist/esm/types/internal.types.d.ts

@@ -1,5 +1,5 @@
 import { ListItem } from './data.types';
 export type InverseIndexReferenceMap = Map<string, InverseIndexValuesMap>;
-export type InverseIndexValuesMap = Map<string, string[]>;
+export type InverseIndexValuesMap = Map<string, Set<string>>;
 export type InverseIndexDataMap = Map<string, InverseIndexDataValuesMap>;
 export type InverseIndexDataValuesMap = Map<string, ListItem>;

package/dist/esm/types/list.types.d.ts

@@ -31,6 +31,16 @@ export type DcuplListOptions<ModelNames extends string = string> = {
     listKey?: string;
     listItemKeys?: string[];
     query?: DcuplGlobalQueryOptions<ListItem>;
+    /**
+     * Controls auto-update for this specific list.
+     * - true: Always auto-update
+     * - false: Never auto-update
+     * - undefined: Inherit from global config
+     *
+     * Overrides global autoUpdateLists setting.
+     * @default undefined
+     */
+    autoUpdate?: boolean;
 };
 export type DcuplRangeOptions = {
     propertyKey: string;

package/dist/esm/types/model.types.d.ts

@@ -56,7 +56,7 @@ export type PropertyBase = {
         separator?: string;
     };
     origin?: string;
-    filter?: boolean | FilterStringSingle | FilterStringArray[] | FilterNumberArray[];
+    filter?: boolean | FilterStringSingle | FilterStringArray[];
     aggregate?: boolean | AggregationOptionsModel;
     meta?: ModelMetadata;
     index?: boolean;
@@ -74,21 +74,37 @@ export type PropertyBoolean = PropertyBase & {
  *  @defaultSnippets { "label": "Int Property", "properties": ["key", "type:int"] }
  */
 export type PropertyInt = PropertyBase & {
-    type: 'int' | 'Array<int>';
+    type: 'int';
+    aggregate?: boolean | AggregationOptionsModel;
+    filter?: boolean;
+};
+/**
+ *  @defaultSnippets { "label": "Int Array Property", "properties": ["key", "type:Array<int>"] }
+ */
+export type PropertyIntArray = PropertyBase & {
+    type: 'Array<int>';
+    separator?: string;
     aggregate?: boolean | AggregationOptionsModel;
-    filter?: boolean | FilterNumberArray[];
+    filter?: boolean;
 };
 /**
  *  @defaultSnippets { "label": "Float Property", "properties": ["key", "type:float"] }
  */
 export type PropertyFloat = PropertyBase & {
-    type: 'float' | 'Array<float>';
+    type: 'float';
     aggregate?: boolean | AggregationOptionsModel;
     fractionDigits?: number;
-    filter?: boolean | FilterNumberArray[];
+    filter?: boolean;
 };
-export type FilterNumberArray = {
-    key: string;
+/**
+ *  @defaultSnippets { "label": "Float Property", "properties": ["key", "type:float"] }
+ */
+export type PropertyFloatArray = PropertyBase & {
+    type: 'Array<float>';
+    separator?: string;
+    aggregate?: boolean | AggregationOptionsModel;
+    fractionDigits?: number;
+    filter?: boolean;
 };
 /**
  *  @defaultSnippets { "label": "Json Property", "properties": ["key", "type:string:json"] }
@@ -104,14 +120,24 @@ export type PropertyAny = PropertyBase & {
     type: 'any' | 'Array<any>';
 };
 /**
- * Example: 'yyyy-MM-dd' | 'dd.MM.yyyy' | ...
+ * Example: 'yyyy-MM-dd' | 'dd.MM.yyyy' | ...
  */
 export type PropertyDateInputFormat = string;
 /**
  *  @defaultSnippets { "label": "Date Property", "properties": ["key", "type:date"] }
  */
 export type PropertyDate = PropertyBase & {
-    type: 'date' | 'Array<date>';
+    type: 'date';
+    inputFormat?: PropertyDateInputFormat;
+    UTC?: boolean;
+    filter?: boolean;
+};
+/**
+ *  @defaultSnippets { "label": "Date Property", "properties": ["key", "type:date"] }
+ */
+export type PropertyDateArray = PropertyBase & {
+    type: 'Array<date>';
+    separator?: string;
     inputFormat?: PropertyDateInputFormat;
     UTC?: boolean;
     filter?: boolean;
@@ -120,11 +146,21 @@ export type PropertyDate = PropertyBase & {
  *  @defaultSnippets { "label": "String Property", "properties": ["key", "type:string:string"] }
  */
 export type PropertyString = PropertyBase & {
-    type: 'string' | 'Array<string>';
+    type: 'string';
+    aggregate?: boolean | AggregationOptionsModel;
     filter?: boolean | FilterStringSingle | FilterStringArray[];
 };
-export type PropertyNumber = PropertyFloat | PropertyInt;
-export type Property = PropertyString | PropertyInt | PropertyFloat | PropertyDate | PropertyJson | PropertyBoolean | PropertyAny;
+/**
+ *  @defaultSnippets { "label": "String Property", "properties": ["key", "type:string:string"] }
+ */
+export type PropertyStringArray = PropertyBase & {
+    type: 'Array<string>';
+    separator?: string;
+    filter?: boolean | FilterStringSingle | FilterStringArray[];
+    aggregate?: boolean | AggregationOptionsModel;
+};
+export type PropertyNumber = PropertyFloat | PropertyInt | PropertyFloatArray | PropertyIntArray;
+export type Property = PropertyString | PropertyStringArray | PropertyInt | PropertyIntArray | PropertyFloat | PropertyFloatArray | PropertyDate | PropertyDateArray | PropertyJson | PropertyBoolean | PropertyAny;
 /**
  * Facet calculation is disabled by default
  */
@@ -160,6 +196,7 @@ export type ReferenceBase = {
     origin?: string;
     filter?: boolean | ReferenceFilterDefinition;
     aggregate?: boolean | AggregationOptionsModel;
+    separator?: string;
     meta?: ModelMetadata;
     index?: boolean;
     validity?: ReferenceValidity;