@privateaim/core-kit 0.8.4 → 0.8.6

package/src/domains/types.ts

@@ -5,94 +5,64 @@
  * view the LICENSE file that was distributed with this source code.
  */
 
-import type { AnalysisBucket, AnalysisBucketEventContext } from './analysis-bucket';
+import type { AnalysisBucket } from './analysis-bucket';
 import type {
     DomainEventName, DomainEventSubscriptionName, DomainSubType, DomainType,
 } from './constants';
-import type { MasterImage, MasterImageEventContext } from './master-image';
-import type { MasterImageGroup, MasterImageGroupEventContext } from './master-image-group';
-import type { Project, ProjectEventContext } from './project';
-import type { ProjectNode, ProjectNodeEventContext } from './project-node';
-import type { Registry, RegistryEventContext } from './registry';
-import type { RegistryProject, RegistryProjectEventContext } from './registry-project';
-import type { Node, NodeEventContext } from './node';
-import type { Analysis, AnalysisEventContext } from './analysis';
-import type { AnalysisBucketFile, AnalysisFileEventContext } from './analysis-bucket-file';
-import type { AnalysisLog, AnalysisLogEventContext } from './analysis-log';
-import type { AnalysisNode, TrainStationEventContext } from './analysis-node';
+import type { MasterImage } from './master-image';
+import type { MasterImageEventLog } from './master-image-event-log';
+import type { MasterImageGroup } from './master-image-group';
+import type { Project } from './project';
+import type { ProjectNode } from './project-node';
+import type { Registry } from './registry';
+import type { RegistryProject } from './registry-project';
+import type { Node } from './node';
+import type { Analysis } from './analysis';
+import type { AnalysisBucketFile } from './analysis-bucket-file';
+import type { AnalysisLog } from './analysis-log';
+import type { AnalysisNode } from './analysis-node';
 
-export type DomainsEventContext = MasterImageEventContext |
-MasterImageGroupEventContext |
-ProjectEventContext |
-ProjectNodeEventContext |
-RegistryEventContext |
-RegistryProjectEventContext |
-NodeEventContext |
-AnalysisEventContext |
-AnalysisLogEventContext |
-AnalysisFileEventContext |
-TrainStationEventContext;
+type DomainTypeMapRaw = {
+    [DomainType.MASTER_IMAGE]: MasterImage,
+    [DomainType.MASTER_IMAGE_EVENT_LOG]: MasterImageEventLog,
+    [DomainType.MASTER_IMAGE_GROUP]: MasterImageGroup,
+    [DomainType.PROJECT]: Project,
+    [DomainType.PROJECT_NODE]: ProjectNode,
+    [DomainSubType.PROJECT_NODE_IN]: ProjectNode,
+    [DomainSubType.PROJECT_NODE_OUT]: ProjectNode,
+    [DomainType.REGISTRY]: Registry,
+    [DomainType.REGISTRY_PROJECT]: RegistryProject
+    [DomainType.NODE]: Node,
+    [DomainType.ANALYSIS]: Analysis,
+    [DomainType.ANALYSIS_BUCKET]: AnalysisBucket,
+    [DomainType.ANALYSIS_BUCKET_FILE]: AnalysisBucketFile,
+    [DomainType.ANALYSIS_LOG]: AnalysisLog,
+    [DomainType.ANALYSIS_NODE]: AnalysisNode,
+    [DomainSubType.ANALYSIS_NODE_IN]: AnalysisNode,
+    [DomainSubType.ANALYSIS_NODE_OUT]: AnalysisNode,
+};
 
-export type DomainEventContext<T extends `${DomainType}` | `${DomainSubType}`> =
-    T extends `${DomainType.MASTER_IMAGE}` ?
-        MasterImageEventContext :
-        T extends `${DomainType.MASTER_IMAGE_GROUP}` ?
-            MasterImageGroupEventContext :
-            T extends `${DomainType.PROJECT}` ?
-                ProjectEventContext :
-                T extends `${DomainType.PROJECT_NODE}` | `${DomainSubType.PROJECT_NODE_IN}` | `${DomainSubType.PROJECT_NODE_OUT}` ?
-                    ProjectNodeEventContext :
-                    T extends `${DomainType.REGISTRY}` ?
-                        RegistryEventContext :
-                        T extends `${DomainType.REGISTRY_PROJECT}` ?
-                            RegistryProjectEventContext :
-                            T extends `${DomainType.NODE}` ?
-                                NodeEventContext :
-                                T extends `${DomainType.ANALYSIS}` ?
-                                    AnalysisEventContext :
-                                    T extends `${DomainType.ANALYSIS_BUCKET}` ?
-                                        AnalysisBucketEventContext :
-                                        T extends `${DomainType.ANALYSIS_LOG}` ?
-                                            AnalysisLogEventContext :
-                                            T extends `${DomainType.ANALYSIS_BUCKET_FILE}` ?
-                                                AnalysisFileEventContext :
-                                                T extends `${DomainType.ANALYSIS_NODE}` | `${DomainSubType.ANALYSIS_NODE_IN}` | `${DomainSubType.ANALYSIS_NODE_OUT}` ?
-                                                    TrainStationEventContext :
-                                                    never;
+export type DomainTypeMap = {
+    [K in keyof DomainTypeMapRaw as `${K}`]: DomainTypeMapRaw[K]
+};
 
-export type DomainEntity<T extends `${DomainType}` | `${DomainSubType}`> =
-    T extends `${DomainType.MASTER_IMAGE}` ?
-        MasterImage :
-        T extends `${DomainType.MASTER_IMAGE_GROUP}` ?
-            MasterImageGroup :
-            T extends `${DomainType.PROJECT}` ?
-                Project :
-                T extends `${DomainType.PROJECT_NODE}` | `${DomainSubType.PROJECT_NODE_IN}` | `${DomainSubType.PROJECT_NODE_OUT}` ?
-                    ProjectNode :
-                    T extends `${DomainType.REGISTRY}` ?
-                        Registry :
-                        T extends `${DomainType.REGISTRY_PROJECT}` ?
-                            RegistryProject :
-                            T extends `${DomainType.NODE}` ?
-                                Node :
-                                T extends `${DomainType.ANALYSIS}` ?
-                                    Analysis :
-                                    T extends `${DomainType.ANALYSIS_BUCKET}` ?
-                                        AnalysisBucket :
-                                        T extends `${DomainType.ANALYSIS_LOG}` ?
-                                            AnalysisLog :
-                                            T extends `${DomainType.ANALYSIS_BUCKET_FILE}` ?
-                                                AnalysisBucketFile :
-                                                T extends `${DomainType.ANALYSIS_NODE}` | `${DomainSubType.ANALYSIS_NODE_IN}` | `${DomainSubType.ANALYSIS_NODE_OUT}` ?
-                                                    AnalysisNode :
-                                                    never;
+export type EventRecord<
+    T extends string,
+    D extends Record<string, any>,
+> = {
+    type: T,
+    data: D,
+    event: `${DomainEventName}`,
+};
 
-export type DomainInput = `${DomainType}` | DomainType | `${DomainSubType}` | DomainSubType;
+export type DomainsEvents = {
+    [T in keyof DomainTypeMap]: EventRecord<T, DomainTypeMap[T]>
+}[keyof DomainTypeMap];
 
 export type DomainEventFullName<
-    T extends DomainInput = DomainInput,
+    T extends string,
 > = `${T}${Capitalize<`${DomainEventName}`>}`;
 
 export type DomainEventSubscriptionFullName<
-    T extends DomainInput = DomainInput,
+    T extends string,
 > = `${T}${Capitalize<`${DomainEventSubscriptionName}`>}`;

package/src/domains/utils.ts

@@ -8,11 +8,13 @@
 import type {
     DomainEventName, DomainEventSubscriptionName,
 } from './constants';
-import type { DomainEventFullName, DomainEventSubscriptionFullName, DomainInput } from './types';
+import type {
+    DomainEventFullName, DomainEventSubscriptionFullName,
+} from './types';
 
-export function buildDomainEventFullName<T extends DomainInput>(
+export function buildDomainEventFullName<T extends string>(
     type: T,
-    event: `${DomainEventName}` | DomainEventName,
+    event: `${DomainEventName}`,
 ) : DomainEventFullName<T> {
     const eventCapitalized = event.substring(0, 1).toUpperCase() + event.substring(1);
 
@@ -20,17 +22,17 @@ export function buildDomainEventFullName<T extends DomainInput>(
 }
 
 export function buildDomainEventSubscriptionFullName<
-    T extends DomainInput,
+    T extends string,
 >(
     type: T,
-    event: `${DomainEventSubscriptionName}` | DomainEventSubscriptionName,
+    event: `${DomainEventSubscriptionName}`,
 ) : DomainEventSubscriptionFullName<T> {
     const eventCapitalized = event.substring(0, 1).toUpperCase() + event.substring(1);
 
     return type + eventCapitalized as DomainEventSubscriptionFullName<T>;
 }
 
-export function buildDomainChannelName(type: DomainInput, id?: string | number) {
+export function buildDomainChannelName(type: string, id?: string | number) {
     return `${type}${id ? `:${id}` : ''}`;
 }