@timothyw/pat-common 1.0.113 → 1.0.116

package/src/types/new/notifications-types.ts

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { notificationTemplateIdSchema, userIdSchema } from '../id-types';
+import { Serialized } from '../../utils';
+
+export const notificationEntityTypeSchema = z.enum([
+    'agenda', 'tasks', 'habits', 'inbox',
+    'agenda_item', 'habit',
+    'agenda_defaults', 'habits_defaults'
+]);
+
+export const notificationTriggerTypeSchema = z.enum(['time_based', 'event_based', 'recurring']);
+
+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(),
+    variables: z.record(z.string()).optional()
+});
+
+export const notificationTemplateSchema = z.object({
+    _id: notificationTemplateIdSchema,
+    userId: userIdSchema,
+    entityType: notificationEntityTypeSchema,
+    entityId: z.string().optional(),
+    name: z.string(),
+    description: z.string().optional(),
+    trigger: notificationTriggerSchema,
+    content: notificationContentSchema,
+    active: z.boolean(),
+    inheritedFrom: notificationTemplateIdSchema.optional(),
+    customized: 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 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 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(),
+        variables: z.record(z.string()).optional()
+    }).optional(),
+    active: z.boolean().optional(),
+    customized: z.boolean().optional()
+});
+
+export const syncNotificationTemplateRequestSchema = z.object({
+    entityType: notificationEntityTypeSchema,
+    entityId: z.string()
+});
+
+export const previewNotificationTemplateRequestSchema = z.object({
+    templateId: notificationTemplateIdSchema,
+    entityData: z.record(z.any()).optional()
+});
+
+export type NotificationEntityType = z.infer<typeof notificationEntityTypeSchema>;
+export type NotificationTriggerType = z.infer<typeof notificationTriggerTypeSchema>;
+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 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 interface CreateNotificationTemplateResponse {
+    template: Serialized<NotificationTemplateData>;
+}
+
+export interface GetNotificationTemplatesResponse {
+    templates: Serialized<NotificationTemplateData>[];
+}
+
+export interface GetNotificationTemplateResponse {
+    template: Serialized<NotificationTemplateData>;
+}
+
+export interface UpdateNotificationTemplateResponse {
+    template: Serialized<NotificationTemplateData>;
+}
+
+export interface DeleteNotificationTemplateResponse {
+    deleted: boolean;
+}
+
+export interface SyncNotificationTemplateResponse {
+    synced: boolean;
+}
+
+export interface PreviewNotificationTemplateResponse {
+    preview: {
+        title: string;
+        body: string;
+    };
+}

package/src/types/new/people-types.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { personIdSchema, personNoteIdSchema, userIdSchema } from '../id-types';
+import { Serialized } from '../../utils';
+
+export const personPropertySchema = z.object({
+    key: z.string(),
+    value: z.string()
+});
+
+export const personNoteSchema = z.object({
+    _id: personNoteIdSchema,
+    personId: personIdSchema,
+    userId: userIdSchema,
+    content: z.string(),
+    createdAt: z.date(),
+    updatedAt: z.date()
+});
+
+export const personDataSchema = z.object({
+    _id: personIdSchema,
+    userId: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    name: z.string(),
+    properties: z.array(personPropertySchema),
+    noteIds: z.array(personNoteIdSchema)
+});
+
+export const personSchema = z.object({
+    _id: personIdSchema,
+    userId: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    name: z.string(),
+    properties: z.array(personPropertySchema),
+    notes: z.array(personNoteSchema)
+});
+
+export const createPersonRequestSchema = z.object({
+    name: z.string().min(1),
+    properties: z.array(z.object({
+        key: z.string().min(1),
+        value: z.string().min(1)
+    })).optional(),
+    notes: z.array(personNoteIdSchema).optional()
+});
+
+export const updatePersonRequestSchema = z.object({
+    name: z.string().min(1).optional(),
+    properties: z.array(z.object({
+        key: z.string().min(1),
+        value: z.string().min(1)
+    })).optional(),
+    noteIds: z.array(personNoteIdSchema).optional()
+});
+
+export const createPersonNoteRequestSchema = z.object({
+    personId: personIdSchema,
+    content: z.string().min(1)
+});
+
+export const updatePersonNoteRequestSchema = z.object({
+    content: z.string().min(1)
+});
+
+export type PersonPropertyData = z.infer<typeof personPropertySchema>;
+export type PersonNoteData = z.infer<typeof personNoteSchema>;
+export type PersonData = z.infer<typeof personDataSchema>;
+export type Person = z.infer<typeof personSchema>;
+
+export type CreatePersonRequest = z.infer<typeof createPersonRequestSchema>;
+export type UpdatePersonRequest = z.infer<typeof updatePersonRequestSchema>;
+export type CreatePersonNoteRequest = z.infer<typeof createPersonNoteRequestSchema>;
+export type UpdatePersonNoteRequest = z.infer<typeof updatePersonNoteRequestSchema>;
+
+export interface CreatePersonResponse {
+    person: Serialized<Person>;
+}
+
+export interface GetPeopleResponse {
+    people: Serialized<Person>[];
+}
+
+export interface GetPersonResponse {
+    person: Serialized<Person>;
+}
+
+export interface UpdatePersonResponse {
+    person: Serialized<Person>;
+}
+
+export interface DeletePersonResponse {
+    deleted: boolean;
+}
+
+export interface CreatePersonNoteResponse {
+    personNote: Serialized<PersonNoteData>;
+}
+
+export interface GetPersonNotesResponse {
+    personNotes: Serialized<PersonNoteData>[];
+}
+
+export interface UpdatePersonNoteResponse {
+    personNote: Serialized<PersonNoteData>;
+}
+
+export interface DeletePersonNoteResponse {
+    deleted: boolean;
+}

package/src/types/new/program-config-types.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+
+export const programConfigSchema = z.object({
+    _requiredBuildVersions: z.object({
+        iOS: z.number(),
+        android: z.number()
+    }),
+    dev: z.object({
+        authorizedEmails: z.array(z.string())
+    }),
+    discord: z.object({
+        token: z.string(),
+        clientId: z.string(),
+        guildId: z.string(),
+        logChannelId: z.string().optional()
+    }),
+    mailjet: z.object({
+        apiKey: z.string(),
+        secretKey: z.string()
+    }),
+    expo: z.object({
+        token: z.string()
+    }),
+    redisUrl: z.string(),
+    updatedAt: z.date(),
+    createdAt: z.date()
+});
+
+export type ProgramConfigData = z.infer<typeof programConfigSchema>;

package/src/types/new/thoughts-types.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { thoughtIdSchema, userIdSchema } from '../id-types';
+import { Serialized } from '../../utils';
+
+export const thoughtSchema = z.object({
+    _id: thoughtIdSchema,
+    userId: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    content: z.string()
+});
+
+export const createThoughtRequestSchema = z.object({
+    content: z.string().min(1)
+});
+
+export const updateThoughtRequestSchema = z.object({
+    content: z.string().min(1)
+});
+
+export type ThoughtData = z.infer<typeof thoughtSchema>;
+
+export type CreateThoughtRequest = z.infer<typeof createThoughtRequestSchema>;
+export type UpdateThoughtRequest = z.infer<typeof updateThoughtRequestSchema>;
+
+export interface CreateThoughtResponse {
+    thought: Serialized<ThoughtData>;
+}
+
+export interface GetThoughtsResponse {
+    thoughts: Serialized<ThoughtData>[];
+}
+
+export interface GetThoughtResponse {
+    thought: Serialized<ThoughtData>;
+}
+
+export interface UpdateThoughtResponse {
+    thought: Serialized<ThoughtData>;
+}
+
+export interface DeleteThoughtResponse {
+    deleted: boolean;
+}

package/src/types/new/user-types.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { userIdSchema } from '../id-types';
+import { Serialized } from '../../utils';
+import { ModuleType } from '../../enums';
+
+export const moduleSchema = z.object({
+    type: z.nativeEnum(ModuleType),
+    visible: z.boolean()
+});
+
+export const deviceSchema = z.object({
+    pushToken: z.string()
+});
+
+export const userSchema = z.object({
+    _id: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    sandbox: z.object({
+        discordId: z.string().optional(),
+        devices: z.array(deviceSchema)
+    }),
+    name: z.string().min(1),
+    timezone: z.string().refine((tz: string) => {
+        try {
+            Intl.DateTimeFormat(undefined, { timeZone: tz });
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }),
+    config: z.object({
+        modules: z.array(moduleSchema),
+        agenda: z.object({
+            itemCategories: z.array(z.string()),
+            itemTypes: z.array(z.string())
+        }),
+        people: z.object({
+            propertyKeys: z.array(z.string())
+        })
+    })
+});
+
+export const updateUserRequestSchema = userSchema
+    .omit({ _id: true, createdAt: true, updatedAt: true })
+    .deepPartial()
+    .strict();
+
+export type UserModuleData = z.infer<typeof moduleSchema>;
+export type UserDeviceData = z.infer<typeof deviceSchema>;
+export type UserData = z.infer<typeof userSchema>;
+
+export type UpdateUserRequest = z.infer<typeof updateUserRequestSchema>;
+
+export interface GetUserResponse {
+    user: Serialized<UserData>;
+}
+
+export interface UpdateUserResponse {
+    user: Serialized<UserData>;
+}

package/src/types/{api → old/api}/account/get-user-types.ts

@@ -1,5 +1,5 @@
 import { UserData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export interface GetUserResponse {
     user: Serialized<UserData>;

package/src/types/{api → old/api}/account/update-user-types.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { UserData, userDataSchema } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const updateUserRequestSchema = userDataSchema
     .omit({ _id: true, createdAt: true, updatedAt: true })

package/src/types/{api → old/api}/auth/create-account-types.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { UserId } from "../../id-types";
+import { UserId } from "../../../id-types";
 
 export const createAccountRequestSchema = z.object({
     name: z.string().trim().min(1),

package/src/types/{api → old/api}/habits/create-habit-entry-types.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { Habit, HabitEntryStatus } from "../../models";
-import { dateOnlyStringSchema } from "../../misc-types";
-import { Serialized } from "../../../utils";
+import { dateOnlyStringSchema } from "../../../misc-types";
+import { Serialized } from "../../../../utils";
 
 export const createHabitEntryRequestSchema = z.object({
     date: dateOnlyStringSchema,

package/src/types/{api → old/api}/habits/create-habit-types.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { Habit, HabitFrequency } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const createHabitRequestSchema = z.object({
     name: z.string().min(1, 'Name is required').trim(),

package/src/types/{api → old/api}/habits/delete-habit-entry-types.ts

@@ -1,5 +1,5 @@
 import { Habit } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export interface DeleteHabitEntryResponse {
     habit: Serialized<Habit>;

package/src/types/{api → old/api}/habits/get-habits-types.ts

@@ -1,5 +1,5 @@
 import { Habit } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export interface GetHabitsResponse {
     habits: Serialized<Habit>[];

package/src/types/{api → old/api}/habits/update-habit-types.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { Habit, HabitFrequency } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const updateHabitRequestSchema = z.object({
     name: z.string().min(1, 'Name is required').trim().optional(),

package/src/types/{api → old/api}/items/complete-item-types.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ItemData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const completeItemRequestSchema = z.object({
     completed: z.boolean()

package/src/types/{api → old/api}/items/create-item-types.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ItemData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const createItemRequestSchema = z.object({
     name: z.string().min(1),

package/src/types/{api → old/api}/items/get-items-types.ts

@@ -1,5 +1,5 @@
 import { ItemData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export interface GetItemsResponse {
     items: Serialized<ItemData>[];

package/src/types/{api → old/api}/items/update-item-types.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ItemData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const updateItemRequestSchema = z.object({
     name: z.string().min(1).optional(),

package/src/types/{api → old/api}/lists/complete-list-item-types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { ListItemData } from "../../models";
 
 export const completeListItemRequestSchema = z.object({

package/src/types/{api → old/api}/lists/create-list-item-types.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { listIdSchema } from '../../id-types';
-import { Serialized } from "../../../utils";
+import { listIdSchema } from '../../../id-types';
+import { Serialized } from "../../../../utils";
 import { ListItemData } from "../../models";
 
 export const createListItemRequestSchema = z.object({

package/src/types/{api → old/api}/lists/create-list-types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { ListData, ListType } from "../../models";
 
 export const createListRequestSchema = z.object({

package/src/types/{api → old/api}/lists/get-list-item-types.ts

@@ -1,4 +1,4 @@
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { ListItemData } from "../../models";
 
 export interface GetListItemsResponse {

package/src/types/{api → old/api}/lists/get-lists-types.ts

@@ -1,4 +1,4 @@
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { ListData } from "../../models";
 
 export interface GetListsResponse {

package/src/types/{api → old/api}/lists/update-list-item-types.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { listIdSchema } from '../../id-types';
-import { Serialized } from "../../../utils";
+import { listIdSchema } from '../../../id-types';
+import { Serialized } from "../../../../utils";
 import { ListItemData } from "../../models";
 
 export const updateListItemRequestSchema = z.object({

package/src/types/{api → old/api}/lists/update-list-types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { ListData, ListType } from "../../models";
 
 export const updateListRequestSchema = z.object({

package/src/types/{api → old/api}/notifications/create-notification-template-types.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { NotificationTemplateData, CreateNotificationTemplateData, notificationEntityTypeSchema, notificationTriggerTypeSchema } from "../../models/notification-template-data";
 
 // Request schema

package/src/types/{api → old/api}/notifications/get-notification-templates-types.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { NotificationTemplateData } from "../../models/notification-template-data";
 
 // Request schema - no body needed for GET

package/src/types/{api → old/api}/notifications/sync-notification-template-types.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { NotificationTemplateData } from "../../models/notification-template-data";
 
 // Request schema

package/src/types/{api → old/api}/notifications/update-notification-template-types.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import {
     NotificationTemplateData,
     notificationTriggerTypeSchema

package/src/types/{api → old/api}/people/create-person-note-types.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { personIdSchema } from "../../id-types";
+import { personIdSchema } from "../../../id-types";
 import { PersonNoteData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const createPersonNoteRequestSchema = z.object({
     personId: personIdSchema,

package/src/types/{api → old/api}/people/create-person-types.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { personNoteIdSchema } from "../../id-types";
+import { personNoteIdSchema } from "../../../id-types";
 import { Person } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const createPersonRequestSchema = z.object({
     name: z.string().min(1),

package/src/types/{api → old/api}/people/get-people-types.ts

@@ -1,5 +1,5 @@
 import { Person } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export interface GetPeopleResponse {
     people: Serialized<Person>[];

package/src/types/{api → old/api}/people/get-person-notes-types.ts

@@ -1,5 +1,5 @@
 import { PersonNoteData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export interface GetPersonNotesResponse {
     personNotes: Serialized<PersonNoteData>[];

package/src/types/{api → old/api}/people/update-person-note-types.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { PersonNoteData } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const updatePersonNoteRequestSchema = z.object({
     content: z.string().min(1)

package/src/types/{api → old/api}/people/update-person-types.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { personNoteIdSchema } from "../../id-types";
+import { personNoteIdSchema } from "../../../id-types";
 import { Person } from "../../models";
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 
 export const updatePersonRequestSchema = z.object({
     name: z.string().min(1).optional(),

package/src/types/{api → old/api}/thoughts/create-thought-types.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { Serialized } from "../../../utils";
+import { Serialized } from "../../../../utils";
 import { ThoughtData } from "../../models";
 
 export const createThoughtRequestSchema = z.object({