@timothyw/pat-common 1.0.123 → 1.0.125

package/src/types/notifications-types.ts

@@ -4,181 +4,76 @@ import { Serialized } from '../utils';
 
 export interface NotificationContext<T = any> {
     entityId: string;
-    entityType: string;
+    entityType: NotificationEntityType;
     entityData: T;
     userId: string;
-    variables: Record<string, any>;
 }
 
-/**
- * @deprecated Use string types with NotificationEntityRegistry instead
- * These enums are kept for backward compatibility during migration
- */
 export enum NotificationParentType {
     AGENDA_PANEL = 'agenda_panel',
 }
 
-/**
- * @deprecated Use string types with NotificationEntityRegistry instead
- * These enums are kept for backward compatibility during migration
- */
 export enum NotificationEntityType {
     INBOX_PANEL = 'inbox_panel',
-    AGENDA_PANEL = 'agenda_panel',
+    AGENDA_PANEL = 'agenda_item',
     AGENDA_ITEM = 'agenda_item',
 }
 
-// Updated to use string instead of enum
-export const notificationEntityTypeSchema = z.string();
-
-export enum NotificationStatus {
-    SCHEDULED = 'scheduled',
-    SENT = 'sent', 
-    FAILED = 'failed',
-    CANCELLED = 'cancelled'
-}
-
 export enum NotificationTriggerType {
     TIME_BASED = 'time_based',
     EVENT_BASED = 'event_based',
     RECURRING = 'recurring'
 }
 
-export const notificationStatusSchema = z.nativeEnum(NotificationStatus);
 export const notificationTriggerTypeSchema = z.nativeEnum(NotificationTriggerType);
 
 export const notificationTriggerSchema = z.object({
     type: notificationTriggerTypeSchema,
-    conditions: z.record(z.any()),
-    timing: z.record(z.any())
-});
-
-export const notificationContentSchema = z.object({
-    title: z.string(),
-    body: z.string()
 });
 
 export const notificationTemplateSchema = z.object({
     _id: notificationTemplateIdSchema,
     userId: userIdSchema,
-    entityType: notificationEntityTypeSchema,
+    entityType: z.nativeEnum(NotificationEntityType),
     entityId: z.string().optional(),
-    name: z.string(),
-    description: z.string().optional(),
     trigger: notificationTriggerSchema,
-    content: notificationContentSchema,
     active: z.boolean(),
     createdAt: z.date(),
     updatedAt: z.date()
 });
 
-export const createNotificationTemplateSchema = notificationTemplateSchema.omit({
-    _id: true,
-    createdAt: true,
-    updatedAt: true
-});
-
-export const entitySyncStateSchema = z.object({
-    userId: userIdSchema,
-    entityType: notificationEntityTypeSchema,
-    entityId: z.string(),
-    synced: z.boolean(),
-    updatedAt: z.date()
-});
-
-export const notificationInstanceSchema = z.object({
-    _id: notificationInstanceIdSchema,
-    templateId: notificationTemplateIdSchema,
-    userId: userIdSchema,
-    entityId: z.string(),
-    scheduledFor: z.date(),
-    status: notificationStatusSchema,
-    sentAt: z.date().optional(),
-    content: z.object({
-        title: z.string(),
-        body: z.string(),
-        data: z.record(z.any()).optional()
-    }),
-    redisId: z.string(),
-    error: z.string().optional(),
-    createdAt: z.date(),
-    updatedAt: z.date()
-});
-
 export const createNotificationTemplateRequestSchema = z.object({
-    entityType: notificationEntityTypeSchema,
+    entityType: z.nativeEnum(NotificationEntityType),
     entityId: z.string().optional(),
-    name: z.string().min(1).max(100),
-    description: z.string().max(500).optional(),
     trigger: z.object({
         type: notificationTriggerTypeSchema,
-        conditions: z.record(z.any()),
-        timing: z.record(z.any())
-    }),
-    content: z.object({
-        title: z.string().min(1).max(200),
-        body: z.string().min(1).max(1000)
     }),
     active: z.boolean().default(true)
 });
 
 export const updateNotificationTemplateRequestSchema = z.object({
-    name: z.string().optional(),
-    description: z.string().optional(),
     trigger: z.object({
         type: notificationTriggerTypeSchema,
-        conditions: z.record(z.any()),
-        timing: z.record(z.any())
-    }).optional(),
-    content: z.object({
-        title: z.string(),
-        body: z.string()
     }).optional(),
     active: z.boolean().optional()
 });
 
-export const syncNotificationTemplateRequestSchema = z.object({
-    sync: z.boolean()
-});
-
-export const previewNotificationTemplateRequestSchema = z.object({
-    templateTitle: z.string(),
-    templateBody: z.string(),
-    entityType: z.string(),
-    entityId: z.string()
-});
-
-export const getNotificationInstancesRequestSchema = z.object({
-    status: z.string().optional(),
-    templateId: z.string().optional(),
-    entityId: z.string().optional(),
-    limit: z.number().optional(),
-    offset: z.number().optional()
-});
-
 export const entitySyncRequestSchema = z.object({
-    entityType: z.string(),
+    entityType: z.nativeEnum(NotificationEntityType),
     entityId: z.string(),
     synced: z.boolean()
 });
 
 export const getEntitySyncRequestSchema = z.object({
-    entityType: z.string(),
+    entityType: z.nativeEnum(NotificationEntityType),
     entityId: z.string()
 });
 
 export type NotificationTrigger = z.infer<typeof notificationTriggerSchema>;
-export type NotificationContent = z.infer<typeof notificationContentSchema>;
 export type NotificationTemplateData = z.infer<typeof notificationTemplateSchema>;
-export type CreateNotificationTemplateData = z.infer<typeof createNotificationTemplateSchema>;
-export type EntitySyncState = z.infer<typeof entitySyncStateSchema>;
-export type NotificationInstanceData = z.infer<typeof notificationInstanceSchema>;
 
 export type CreateNotificationTemplateRequest = z.infer<typeof createNotificationTemplateRequestSchema>;
 export type UpdateNotificationTemplateRequest = z.infer<typeof updateNotificationTemplateRequestSchema>;
-export type SyncNotificationTemplateRequest = z.infer<typeof syncNotificationTemplateRequestSchema>;
-export type PreviewNotificationTemplateRequest = z.infer<typeof previewNotificationTemplateRequestSchema>;
-export type GetNotificationInstancesRequest = z.infer<typeof getNotificationInstancesRequestSchema>;
 export type EntitySyncRequest = z.infer<typeof entitySyncRequestSchema>;
 export type GetEntitySyncRequest = z.infer<typeof getEntitySyncRequestSchema>;
 
@@ -200,24 +95,6 @@ export interface UpdateNotificationTemplateResponse {
 
 export interface DeleteNotificationTemplateResponse {}
 
-export interface SyncNotificationTemplateResponse {
-    synced: boolean;
-}
-
-export interface PreviewNotificationTemplateResponse {
-    preview: {
-        title: string;
-        body: string;
-    };
-}
-
-export interface GetNotificationInstancesResponse {
-    success: boolean;
-    instances?: Serialized<NotificationInstanceData>[];
-    total?: number;
-    error?: string;
-}
-
 export interface EntitySyncResponse {
     success: boolean;
     synced: boolean;

package/src/notification-entity-registry.ts

@@ -1,241 +0,0 @@
-import {
-    NotificationEntityConfig,
-    ParentResolver,
-    ParentResolutionResult,
-    StaticParentResolver,
-    DynamicParentResolver
-} from './types/notification-entity-config';
-
-/**
- * Registry for managing notification entity configurations and parent resolution
- */
-export class NotificationEntityRegistry {
-    private static instance: NotificationEntityRegistry;
-    private entityConfigs: Map<string, NotificationEntityConfig> = new Map();
-
-    private constructor() {
-        // Initialize with default configurations
-        this.registerDefaultEntities();
-    }
-
-    /**
-     * Get the singleton instance
-     */
-    static getInstance(): NotificationEntityRegistry {
-        if (!NotificationEntityRegistry.instance) {
-            NotificationEntityRegistry.instance = new NotificationEntityRegistry();
-        }
-        return NotificationEntityRegistry.instance;
-    }
-
-    /**
-     * Register a new entity configuration
-     */
-    registerEntity(config: NotificationEntityConfig): void {
-        this.entityConfigs.set(config.entityType, config);
-    }
-
-    /**
-     * Get configuration for an entity type
-     */
-    getEntityConfig(entityType: string): NotificationEntityConfig | null {
-        return this.entityConfigs.get(entityType) || null;
-    }
-
-    /**
-     * Get all registered entity types
-     */
-    getEntityTypes(): string[] {
-        return Array.from(this.entityConfigs.keys());
-    }
-
-    /**
-     * Get all entity configurations
-     */
-    getAllConfigs(): NotificationEntityConfig[] {
-        return Array.from(this.entityConfigs.values());
-    }
-
-    /**
-     * Resolve the parent type for a specific entity instance
-     */
-    resolveParent(entityType: string, entityData: any): ParentResolutionResult | null {
-        const config = this.entityConfigs.get(entityType);
-        if (!config) {
-            return null;
-        }
-
-        const resolver = config.parentResolver;
-
-        if (resolver.type === 'static') {
-            return this.resolveStaticParent(resolver);
-        } else {
-            return this.resolveDynamicParent(resolver, entityData);
-        }
-    }
-
-    /**
-     * Check if an entity type supports dynamic parent resolution
-     */
-    isDynamicParentType(entityType: string): boolean {
-        const config = this.entityConfigs.get(entityType);
-        return config?.parentResolver.type === 'dynamic' || false;
-    }
-
-    /**
-     * Get the parent property name for dynamic resolution
-     */
-    getParentProperty(entityType: string): string | null {
-        const config = this.entityConfigs.get(entityType);
-        if (config?.parentResolver.type === 'dynamic') {
-            return config.parentResolver.parentProperty;
-        }
-        return null;
-    }
-
-    /**
-     * Get display name for an entity type
-     */
-    getDisplayName(entityType: string): string {
-        const config = this.entityConfigs.get(entityType);
-        return config?.displayName || entityType;
-    }
-
-    /**
-     * Get icon for an entity type
-     */
-    getIcon(entityType: string): string | null {
-        const config = this.entityConfigs.get(entityType);
-        return config?.icon || null;
-    }
-
-    /**
-     * Check if entity type exists
-     */
-    hasEntityType(entityType: string): boolean {
-        return this.entityConfigs.has(entityType);
-    }
-
-    /**
-     * Remove an entity configuration
-     */
-    unregisterEntity(entityType: string): boolean {
-        return this.entityConfigs.delete(entityType);
-    }
-
-    /**
-     * Clear all configurations
-     */
-    clear(): void {
-        this.entityConfigs.clear();
-    }
-
-    /**
-     * Resolve static parent type
-     */
-    private resolveStaticParent(resolver: StaticParentResolver): ParentResolutionResult {
-        return {
-            parentType: resolver.parentType,
-            isDynamic: false
-        };
-    }
-
-    /**
-     * Resolve dynamic parent type based on entity data
-     */
-    private resolveDynamicParent(resolver: DynamicParentResolver, entityData: any): ParentResolutionResult {
-        const propertyValue = entityData?.[resolver.parentProperty];
-        
-        if (propertyValue && typeof propertyValue === 'string' && propertyValue.trim()) {
-            // Use the property value to construct the parent type
-            const parentType = resolver.parentTypePrefix + propertyValue.trim();
-            return {
-                parentType,
-                isDynamic: true,
-                resolvedProperty: propertyValue.trim(),
-                usedFallback: false
-            };
-        }
-
-        // Fall back to default parent
-        return {
-            parentType: resolver.fallbackParent,
-            isDynamic: true,
-            usedFallback: true
-        };
-    }
-
-    /**
-     * Register default entity configurations
-     */
-    private registerDefaultEntities(): void {
-        // Agenda Panel (dynamic parent for agenda items based on category)
-        this.registerEntity({
-            entityType: 'agenda_panel',
-            parentResolver: {
-                type: 'static',
-                parentType: 'agenda_panel' // Panel level templates
-            },
-            displayName: 'Agenda Panel',
-            icon: 'calendar',
-            description: 'Default agenda panel templates'
-        });
-
-        // Agenda Item (dynamic parent based on category)
-        this.registerEntity({
-            entityType: 'agenda_item',
-            parentResolver: {
-                type: 'dynamic',
-                parentProperty: 'category',
-                parentTypePrefix: 'agenda_category_',
-                fallbackParent: 'agenda_panel'
-            },
-            displayName: 'Agenda Item',
-            icon: 'calendar',
-            description: 'Individual agenda item notifications'
-        });
-
-        // Habits Panel (static parent for habits)
-        this.registerEntity({
-            entityType: 'habits_panel',
-            parentResolver: {
-                type: 'static',
-                parentType: 'habits_panel'
-            },
-            displayName: 'Habits Panel',
-            icon: 'fitness',
-            description: 'Default habits panel templates'
-        });
-
-        // Habit (static parent - all habits inherit from habits panel)
-        this.registerEntity({
-            entityType: 'habit',
-            parentResolver: {
-                type: 'static',
-                parentType: 'habits_panel'
-            },
-            displayName: 'Habit',
-            icon: 'fitness',
-            description: 'Individual habit notifications'
-        });
-
-        // Inbox Panel (no parent - top level)
-        this.registerEntity({
-            entityType: 'inbox_panel',
-            parentResolver: {
-                type: 'static',
-                parentType: '' // No parent - this is a top-level entity
-            },
-            displayName: 'Inbox Panel',
-            icon: 'mail',
-            description: 'Inbox notifications'
-        });
-    }
-}
-
-/**
- * Convenience function to get the singleton instance
- */
-export function getNotificationEntityRegistry(): NotificationEntityRegistry {
-    return NotificationEntityRegistry.getInstance();
-}

package/src/types/notification-entity-config.ts

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-
-/**
- * Static parent resolver - entity always inherits from the same parent type
- */
-export interface StaticParentResolver {
-    type: 'static';
-    parentType: string;
-}
-
-/**
- * Dynamic parent resolver - parent determined by entity properties
- */
-export interface DynamicParentResolver {
-    type: 'dynamic';
-    parentProperty: string; // Property name on entity (e.g., 'category')
-    parentTypePrefix: string; // Prefix for parent type (e.g., 'agenda_category_')
-    fallbackParent: string; // Default parent if property is missing/empty
-}
-
-export type ParentResolver = StaticParentResolver | DynamicParentResolver;
-
-/**
- * Configuration for a notification entity type
- */
-export interface NotificationEntityConfig {
-    entityType: string;
-    parentResolver: ParentResolver;
-    displayName: string;
-    icon?: string;
-    description?: string;
-}
-
-/**
- * Result of parent resolution for a specific entity instance
- */
-export interface ParentResolutionResult {
-    parentType: string;
-    isDynamic: boolean;
-    resolvedProperty?: string;
-    usedFallback?: boolean;
-}
-
-/**
- * Zod schemas for validation
- */
-export const staticParentResolverSchema = z.object({
-    type: z.literal('static'),
-    parentType: z.string()
-});
-
-export const dynamicParentResolverSchema = z.object({
-    type: z.literal('dynamic'),
-    parentProperty: z.string(),
-    parentTypePrefix: z.string(),
-    fallbackParent: z.string()
-});
-
-export const parentResolverSchema = z.union([
-    staticParentResolverSchema,
-    dynamicParentResolverSchema
-]);
-
-export const notificationEntityConfigSchema = z.object({
-    entityType: z.string(),
-    parentResolver: parentResolverSchema,
-    displayName: z.string(),
-    icon: z.string().optional(),
-    description: z.string().optional()
-});
-
-/**
- * Type exports
- */
-export type StaticParentResolverData = z.infer<typeof staticParentResolverSchema>;
-export type DynamicParentResolverData = z.infer<typeof dynamicParentResolverSchema>;
-export type ParentResolverData = z.infer<typeof parentResolverSchema>;
-export type NotificationEntityConfigData = z.infer<typeof notificationEntityConfigSchema>;