@timothyw/pat-common 1.0.100 → 1.0.102

package/src/types/api/notifications/create-notification-template-types.ts

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData, CreateNotificationTemplateData, notificationEntityTypeSchema, notificationTriggerTypeSchema } from "../../models/notification-template-data";
+
+// Request schema
+export const createNotificationTemplateRequestSchema = z.object({
+    entityType: notificationEntityTypeSchema,
+    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),
+        variables: z.record(z.string()).optional()
+    }),
+    active: z.boolean().default(true),
+    inheritedFrom: z.string().optional(),
+    customized: z.boolean().default(false)
+});
+
+export type CreateNotificationTemplateRequest = z.infer<typeof createNotificationTemplateRequestSchema>;
+
+// Response schema
+export const createNotificationTemplateResponseSchema = z.object({
+    success: z.boolean(),
+    template: z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: z.string().optional()
+});
+
+export type CreateNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};

package/src/types/api/notifications/delete-notification-template-types.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+// Request schema - no body needed for DELETE
+export const deleteNotificationTemplateRequestSchema = z.object({});
+
+export type DeleteNotificationTemplateRequest = z.infer<typeof deleteNotificationTemplateRequestSchema>;
+
+// Response schema
+export const deleteNotificationTemplateResponseSchema = z.object({
+    success: z.boolean(),
+    error: z.string().optional()
+});
+
+export type DeleteNotificationTemplateResponse = z.infer<typeof deleteNotificationTemplateResponseSchema>;

package/src/types/api/notifications/get-notification-instances-types.ts

@@ -0,0 +1,29 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationInstanceData } from "../../models/notification-instance-data";
+
+// Request schema - query parameters
+export const getNotificationInstancesRequestSchema = z.object({
+    status: z.string().optional(), // filter by status
+    templateId: z.string().optional(), // filter by template
+    entityId: z.string().optional(), // filter by entity
+    limit: z.number().optional(), // pagination
+    offset: z.number().optional() // pagination
+});
+
+export type GetNotificationInstancesRequest = z.infer<typeof getNotificationInstancesRequestSchema>;
+
+// Response schema
+export const getNotificationInstancesResponseSchema = z.object({
+    success: z.boolean(),
+    instances: z.array(z.any()).optional(), // Will be Serialized<NotificationInstanceData>[]
+    total: z.number().optional(),
+    error: z.string().optional()
+});
+
+export type GetNotificationInstancesResponse = {
+    success: boolean;
+    instances?: Serialized<NotificationInstanceData>[];
+    total?: number;
+    error?: string;
+};

package/src/types/api/notifications/get-notification-templates-types.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData } from "../../models/notification-template-data";
+
+// Request schema - no body needed for GET
+export const getNotificationTemplatesRequestSchema = z.object({});
+
+export type GetNotificationTemplatesRequest = z.infer<typeof getNotificationTemplatesRequestSchema>;
+
+// Response schema
+export const getNotificationTemplatesResponseSchema = z.object({
+    success: z.boolean(),
+    templates: z.array(z.any()).optional(), // Will be Serialized<NotificationTemplateData>[]
+    error: z.string().optional()
+});
+
+export type GetNotificationTemplatesResponse = {
+    success: boolean;
+    templates?: Serialized<NotificationTemplateData>[];
+    error?: string;
+};

package/src/types/api/notifications/index.ts

@@ -0,0 +1,7 @@
+export * from './get-notification-templates-types';
+export * from './create-notification-template-types';
+export * from './update-notification-template-types';
+export * from './delete-notification-template-types';
+export * from './get-notification-instances-types';
+export * from './preview-notification-template-types';
+export * from './sync-notification-template-types';

package/src/types/api/notifications/preview-notification-template-types.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+
+// Request schema
+export const previewNotificationTemplateRequestSchema = z.object({
+    templateTitle: z.string(),
+    templateBody: z.string(),
+    entityType: z.string(),
+    entityId: z.string(),
+    variables: z.record(z.any()).optional()
+});
+
+export type PreviewNotificationTemplateRequest = z.infer<typeof previewNotificationTemplateRequestSchema>;
+
+// Response schema
+export const previewNotificationTemplateResponseSchema = z.object({
+    success: z.boolean(),
+    preview: z.object({
+        title: z.string(),
+        body: z.string(),
+        variables: z.record(z.any())
+    }).optional(),
+    missingVariables: z.array(z.string()).optional(),
+    error: z.string().optional()
+});
+
+export type PreviewNotificationTemplateResponse = z.infer<typeof previewNotificationTemplateResponseSchema>;

package/src/types/api/notifications/sync-notification-template-types.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData } from "../../models/notification-template-data";
+
+// Request schema
+export const syncNotificationTemplateRequestSchema = z.object({
+    sync: z.boolean() // true to sync with parent, false to unsync
+});
+
+export type SyncNotificationTemplateRequest = z.infer<typeof syncNotificationTemplateRequestSchema>;
+
+// Response schema
+export const syncNotificationTemplateResponseSchema = z.object({
+    success: z.boolean(),
+    template: z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: z.string().optional()
+});
+
+export type SyncNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};

package/src/types/api/notifications/update-notification-template-types.ts

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { Serialized } from "../../../utils";
+import { NotificationTemplateData, notificationEntityTypeSchema, notificationTriggerTypeSchema } from "../../models/notification-template-data";
+
+// Request schema
+export const updateNotificationTemplateRequestSchema = z.object({
+    name: z.string().min(1).max(100).optional(),
+    description: z.string().max(500).optional(),
+    trigger: z.object({
+        type: notificationTriggerTypeSchema,
+        conditions: z.record(z.any()),
+        timing: z.record(z.any())
+    }).optional(),
+    content: z.object({
+        title: z.string().min(1).max(200),
+        body: z.string().min(1).max(1000),
+        variables: z.record(z.string()).optional()
+    }).optional(),
+    active: z.boolean().optional(),
+    customized: z.boolean().optional()
+});
+
+export type UpdateNotificationTemplateRequest = z.infer<typeof updateNotificationTemplateRequestSchema>;
+
+// Response schema
+export const updateNotificationTemplateResponseSchema = z.object({
+    success: z.boolean(),
+    template: z.any().optional(), // Will be Serialized<NotificationTemplateData>
+    error: z.string().optional()
+});
+
+export type UpdateNotificationTemplateResponse = {
+    success: boolean;
+    template?: Serialized<NotificationTemplateData>;
+    error?: string;
+};

package/src/types/api/tasks/get-tasks-types.ts

@@ -2,5 +2,5 @@ import { Serialized } from "../../../utils";
 import { TaskData } from "../../models";
 
 export interface GetTasksResponse {
-    tasks: Serialized<TaskData>;
+    tasks: Serialized<TaskData>[];
 }

package/src/types/id-types.ts

@@ -28,4 +28,10 @@ export const habitIdSchema = z.string().transform((val): TaskListId => val as Ta
 export type HabitId = string & { readonly __brand: "HabitId" };
 
 export const habitEntryIdSchema = z.string().transform((val): TaskListId => val as TaskListId);
-export type HabitEntryId = string & { readonly __brand: "HabitEntryId" };
+export type HabitEntryId = string & { readonly __brand: "HabitEntryId" };
+
+export const notificationTemplateIdSchema = z.string().transform((val): NotificationTemplateId => val as NotificationTemplateId);
+export type NotificationTemplateId = string & { readonly __brand: "NotificationTemplateId" };
+
+export const notificationInstanceIdSchema = z.string().transform((val): NotificationInstanceId => val as NotificationInstanceId);
+export type NotificationInstanceId = string & { readonly __brand: "NotificationInstanceId" };

package/src/types/models/index.ts

@@ -1,6 +1,9 @@
 export * from './auth-data';
 export * from './habit-data';
 export * from './item-data';
+export * from './notification-template-data';
+export * from './notification-instance-data';
+export * from './notifiable';
 export * from './person-data';
 export * from './program-config';
 export * from './task-data';

package/src/types/models/notifiable.ts

@@ -0,0 +1,52 @@
+import { NotificationTemplateData, NotificationEntityType } from "./notification-template-data";
+
+export interface NotificationContext<T = any> {
+    entityId: string;
+    entityType: NotificationEntityType;
+    entityData: T;
+    userId: string;
+    // Additional context for template variable replacement
+    variables: Record<string, any>;
+}
+
+export interface INotifiable<T = any> {
+    /**
+     * Get the ID of this notifiable entity
+     */
+    getId(): string;
+    
+    /**
+     * Get the entity type for notification purposes
+     */
+    getNotificationEntityType(): NotificationEntityType;
+    
+    /**
+     * Get context data for notification template variables
+     */
+    getNotificationContext(): NotificationContext<T>;
+    
+    /**
+     * Get inherited notification templates from parent entities
+     */
+    getInheritedNotificationTemplates(): Promise<NotificationTemplateData[]>;
+    
+    /**
+     * Get custom notification templates specific to this entity
+     */
+    getCustomNotificationTemplates(): Promise<NotificationTemplateData[]>;
+    
+    /**
+     * Get all effective notification templates (inherited + custom)
+     */
+    getAllNotificationTemplates(): Promise<NotificationTemplateData[]>;
+    
+    /**
+     * Register notification triggers when entity is created/updated
+     */
+    registerNotificationTriggers(): Promise<void>;
+    
+    /**
+     * Remove notification triggers when entity is deleted
+     */
+    removeNotificationTriggers(): Promise<void>;
+}

package/src/types/models/notification-instance-data.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { NotificationInstanceId, NotificationTemplateId, UserId } from "../id-types";
+
+export const notificationStatusSchema = z.enum(['scheduled', 'sent', 'failed', 'cancelled']);
+export type NotificationStatus = z.infer<typeof notificationStatusSchema>;
+
+export const notificationInstanceDataSchema = z.object({
+    _id: z.string().transform((val): NotificationInstanceId => val as NotificationInstanceId),
+    templateId: z.string().transform((val): NotificationTemplateId => val as NotificationTemplateId),
+    userId: z.string().transform((val): UserId => val as UserId),
+    entityId: z.string(), // ID of the specific entity this notification is for
+    scheduledFor: z.date(),
+    status: notificationStatusSchema,
+    sentAt: z.date().optional(),
+    content: z.object({
+        title: z.string(),
+        body: z.string(),
+        data: z.record(z.any()).optional() // additional data for the notification
+    }),
+    redisId: z.string(), // link to Redis scheduled notification for coordination
+    error: z.string().optional(), // error message if status is 'failed'
+    createdAt: z.date(),
+    updatedAt: z.date()
+});
+
+export type NotificationInstanceData = z.infer<typeof notificationInstanceDataSchema>;
+
+// Helper type for creating new instances (without _id, dates, status)
+export const createNotificationInstanceSchema = notificationInstanceDataSchema.omit({
+    _id: true,
+    status: true,
+    sentAt: true,
+    error: true,
+    createdAt: true,
+    updatedAt: true
+}).extend({
+    status: notificationStatusSchema.default('scheduled')
+});
+
+export type CreateNotificationInstanceData = z.infer<typeof createNotificationInstanceSchema>;

package/src/types/models/notification-template-data.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { NotificationTemplateId, UserId } from "../id-types";
+
+export const notificationEntityTypeSchema = z.enum(['agenda', 'tasks', 'habits', 'agenda_item', 'task_list', 'task', 'habit']);
+export type NotificationEntityType = z.infer<typeof notificationEntityTypeSchema>;
+
+export const notificationTriggerTypeSchema = z.enum(['time_based', 'event_based', 'recurring']);
+export type NotificationTriggerType = z.infer<typeof notificationTriggerTypeSchema>;
+
+export const notificationTriggerSchema = z.object({
+    type: notificationTriggerTypeSchema,
+    conditions: z.record(z.any()), // flexible conditions object
+    timing: z.record(z.any()) // timing configuration like "5 minutes before due"
+});
+export type NotificationTrigger = z.infer<typeof notificationTriggerSchema>;
+
+export const notificationContentSchema = z.object({
+    title: z.string(),
+    body: z.string(),
+    // Support for template variables like {{entity.name}}
+    variables: z.record(z.string()).optional()
+});
+export type NotificationContent = z.infer<typeof notificationContentSchema>;
+
+export const notificationTemplateDataSchema = z.object({
+    _id: z.string().transform((val): NotificationTemplateId => val as NotificationTemplateId),
+    userId: z.string().transform((val): UserId => val as UserId),
+    entityType: notificationEntityTypeSchema,
+    entityId: z.string().optional(), // null/undefined for panel-level templates
+    name: z.string(),
+    description: z.string().optional(),
+    trigger: notificationTriggerSchema,
+    content: notificationContentSchema,
+    active: z.boolean().default(true),
+    inheritedFrom: z.string().transform((val): NotificationTemplateId => val as NotificationTemplateId).optional(),
+    customized: z.boolean().default(false), // true if user modified inherited template
+    createdAt: z.date(),
+    updatedAt: z.date()
+});
+
+export type NotificationTemplateData = z.infer<typeof notificationTemplateDataSchema>;
+
+// Helper type for creating new templates (without _id, dates)
+export const createNotificationTemplateSchema = notificationTemplateDataSchema.omit({
+    _id: true,
+    createdAt: true,
+    updatedAt: true
+});
+
+export type CreateNotificationTemplateData = z.infer<typeof createNotificationTemplateSchema>;

package/src/utils/serializing-utils.ts

@@ -5,6 +5,8 @@ import {
     ItemData, Person,
     PersonData,
     PersonNoteData,
+    NotificationTemplateData,
+    NotificationInstanceData,
     TaskData, TaskListData,
     ThoughtData,
     UserData
@@ -126,6 +128,22 @@ export class Serializer {
     static deserializeUserData(data: Serialized<UserData>): UserData {
         return this.deserialize(data) as unknown as UserData;
     }
+
+    static serializeNotificationTemplateData(data: NotificationTemplateData): Serialized<NotificationTemplateData> {
+        return this.serialize(data);
+    }
+
+    static deserializeNotificationTemplateData(data: Serialized<NotificationTemplateData>): NotificationTemplateData {
+        return this.deserialize(data) as unknown as NotificationTemplateData;
+    }
+
+    static serializeNotificationInstanceData(data: NotificationInstanceData): Serialized<NotificationInstanceData> {
+        return this.serialize(data);
+    }
+
+    static deserializeNotificationInstanceData(data: Serialized<NotificationInstanceData>): NotificationInstanceData {
+        return this.deserialize(data) as unknown as NotificationInstanceData;
+    }
 }
 
 function serializeRecursive(obj: any): any {