@timothyw/pat-common 1.0.118 → 1.0.120

package/dist/types/user-types.d.ts

@@ -0,0 +1,283 @@
+import { z } from 'zod';
+import { Serialized } from '../utils';
+import { ModuleType } from '../enums';
+export declare const moduleSchema: z.ZodObject<{
+    type: z.ZodNativeEnum<typeof ModuleType>;
+    visible: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    type: ModuleType;
+    visible: boolean;
+}, {
+    type: ModuleType;
+    visible: boolean;
+}>;
+export declare const deviceSchema: z.ZodObject<{
+    pushToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    pushToken: string;
+}, {
+    pushToken: string;
+}>;
+export declare const userSchema: z.ZodObject<{
+    _id: z.ZodEffects<z.ZodString, import("./id-types").UserId, string>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+    sandbox: z.ZodObject<{
+        discordId: z.ZodOptional<z.ZodString>;
+        devices: z.ZodArray<z.ZodObject<{
+            pushToken: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            pushToken: string;
+        }, {
+            pushToken: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        devices: {
+            pushToken: string;
+        }[];
+        discordId?: string | undefined;
+    }, {
+        devices: {
+            pushToken: string;
+        }[];
+        discordId?: string | undefined;
+    }>;
+    name: z.ZodString;
+    timezone: z.ZodEffects<z.ZodString, string, string>;
+    config: z.ZodObject<{
+        modules: z.ZodArray<z.ZodObject<{
+            type: z.ZodNativeEnum<typeof ModuleType>;
+            visible: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            type: ModuleType;
+            visible: boolean;
+        }, {
+            type: ModuleType;
+            visible: boolean;
+        }>, "many">;
+        agenda: z.ZodObject<{
+            itemCategories: z.ZodArray<z.ZodString, "many">;
+            itemTypes: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            itemCategories: string[];
+            itemTypes: string[];
+        }, {
+            itemCategories: string[];
+            itemTypes: string[];
+        }>;
+        people: z.ZodObject<{
+            propertyKeys: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            propertyKeys: string[];
+        }, {
+            propertyKeys: string[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        agenda: {
+            itemCategories: string[];
+            itemTypes: string[];
+        };
+        people: {
+            propertyKeys: string[];
+        };
+        modules: {
+            type: ModuleType;
+            visible: boolean;
+        }[];
+    }, {
+        agenda: {
+            itemCategories: string[];
+            itemTypes: string[];
+        };
+        people: {
+            propertyKeys: string[];
+        };
+        modules: {
+            type: ModuleType;
+            visible: boolean;
+        }[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    _id: string & {
+        readonly __brand: "UserId";
+    };
+    createdAt: Date;
+    updatedAt: Date;
+    name: string;
+    sandbox: {
+        devices: {
+            pushToken: string;
+        }[];
+        discordId?: string | undefined;
+    };
+    timezone: string;
+    config: {
+        agenda: {
+            itemCategories: string[];
+            itemTypes: string[];
+        };
+        people: {
+            propertyKeys: string[];
+        };
+        modules: {
+            type: ModuleType;
+            visible: boolean;
+        }[];
+    };
+}, {
+    _id: string;
+    createdAt: Date;
+    updatedAt: Date;
+    name: string;
+    sandbox: {
+        devices: {
+            pushToken: string;
+        }[];
+        discordId?: string | undefined;
+    };
+    timezone: string;
+    config: {
+        agenda: {
+            itemCategories: string[];
+            itemTypes: string[];
+        };
+        people: {
+            propertyKeys: string[];
+        };
+        modules: {
+            type: ModuleType;
+            visible: boolean;
+        }[];
+    };
+}>;
+export declare const updateUserRequestSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    sandbox: z.ZodOptional<z.ZodObject<{
+        discordId: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        devices: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            pushToken: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            pushToken?: string | undefined;
+        }, {
+            pushToken?: string | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        discordId?: string | undefined;
+        devices?: {
+            pushToken?: string | undefined;
+        }[] | undefined;
+    }, {
+        discordId?: string | undefined;
+        devices?: {
+            pushToken?: string | undefined;
+        }[] | undefined;
+    }>>;
+    timezone: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
+    config: z.ZodOptional<z.ZodObject<{
+        modules: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodOptional<z.ZodNativeEnum<typeof ModuleType>>;
+            visible: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type?: ModuleType | undefined;
+            visible?: boolean | undefined;
+        }, {
+            type?: ModuleType | undefined;
+            visible?: boolean | undefined;
+        }>, "many">>;
+        agenda: z.ZodOptional<z.ZodObject<{
+            itemCategories: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            itemTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            itemCategories?: string[] | undefined;
+            itemTypes?: string[] | undefined;
+        }, {
+            itemCategories?: string[] | undefined;
+            itemTypes?: string[] | undefined;
+        }>>;
+        people: z.ZodOptional<z.ZodObject<{
+            propertyKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            propertyKeys?: string[] | undefined;
+        }, {
+            propertyKeys?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        agenda?: {
+            itemCategories?: string[] | undefined;
+            itemTypes?: string[] | undefined;
+        } | undefined;
+        people?: {
+            propertyKeys?: string[] | undefined;
+        } | undefined;
+        modules?: {
+            type?: ModuleType | undefined;
+            visible?: boolean | undefined;
+        }[] | undefined;
+    }, {
+        agenda?: {
+            itemCategories?: string[] | undefined;
+            itemTypes?: string[] | undefined;
+        } | undefined;
+        people?: {
+            propertyKeys?: string[] | undefined;
+        } | undefined;
+        modules?: {
+            type?: ModuleType | undefined;
+            visible?: boolean | undefined;
+        }[] | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    name?: string | undefined;
+    sandbox?: {
+        discordId?: string | undefined;
+        devices?: {
+            pushToken?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    timezone?: string | undefined;
+    config?: {
+        agenda?: {
+            itemCategories?: string[] | undefined;
+            itemTypes?: string[] | undefined;
+        } | undefined;
+        people?: {
+            propertyKeys?: string[] | undefined;
+        } | undefined;
+        modules?: {
+            type?: ModuleType | undefined;
+            visible?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+}, {
+    name?: string | undefined;
+    sandbox?: {
+        discordId?: string | undefined;
+        devices?: {
+            pushToken?: string | undefined;
+        }[] | undefined;
+    } | undefined;
+    timezone?: string | undefined;
+    config?: {
+        agenda?: {
+            itemCategories?: string[] | undefined;
+            itemTypes?: string[] | undefined;
+        } | undefined;
+        people?: {
+            propertyKeys?: string[] | undefined;
+        } | undefined;
+        modules?: {
+            type?: ModuleType | undefined;
+            visible?: boolean | undefined;
+        }[] | undefined;
+    } | undefined;
+}>;
+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/dist/types/user-types.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateUserRequestSchema = exports.userSchema = exports.deviceSchema = exports.moduleSchema = void 0;
+const zod_1 = require("zod");
+const id_types_1 = require("./id-types");
+const enums_1 = require("../enums");
+exports.moduleSchema = zod_1.z.object({
+    type: zod_1.z.nativeEnum(enums_1.ModuleType),
+    visible: zod_1.z.boolean()
+});
+exports.deviceSchema = zod_1.z.object({
+    pushToken: zod_1.z.string()
+});
+exports.userSchema = zod_1.z.object({
+    _id: id_types_1.userIdSchema,
+    createdAt: zod_1.z.date(),
+    updatedAt: zod_1.z.date(),
+    sandbox: zod_1.z.object({
+        discordId: zod_1.z.string().optional(),
+        devices: zod_1.z.array(exports.deviceSchema)
+    }),
+    name: zod_1.z.string().min(1),
+    timezone: zod_1.z.string().refine((tz) => {
+        try {
+            Intl.DateTimeFormat(undefined, { timeZone: tz });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }),
+    config: zod_1.z.object({
+        modules: zod_1.z.array(exports.moduleSchema),
+        agenda: zod_1.z.object({
+            itemCategories: zod_1.z.array(zod_1.z.string()),
+            itemTypes: zod_1.z.array(zod_1.z.string())
+        }),
+        people: zod_1.z.object({
+            propertyKeys: zod_1.z.array(zod_1.z.string())
+        })
+    })
+});
+exports.updateUserRequestSchema = exports.userSchema
+    .omit({ _id: true, createdAt: true, updatedAt: true })
+    .deepPartial()
+    .strict();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@timothyw/pat-common",
   "description": "",
   "author": "Timothy Washburn",
-  "version": "1.0.118",
+  "version": "1.0.120",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {

package/src/types/{new/agenda-types.ts → agenda-types.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { itemIdSchema, userIdSchema } from '../id-types';
-import { Serialized } from '../../utils';
+import { itemIdSchema, userIdSchema } from './id-types';
+import { Serialized } from '../utils';
 
 export const agendaItemSchema = z.object({
     _id: itemIdSchema,

package/src/types/{new/auth-types.ts → auth-types.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { authIdSchema, userIdSchema } from '../id-types';
+import { authIdSchema, userIdSchema } from './id-types';
 
 export const authTokensSchema = z.object({
     accessToken: z.string(),

package/src/types/{new/habits-types.ts → habits-types.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { habitIdSchema, habitEntryIdSchema, userIdSchema } from '../id-types';
-import { dateOnlyStringSchema } from '../misc-types';
-import { Serialized } from '../../utils';
+import { habitIdSchema, habitEntryIdSchema, userIdSchema } from './id-types';
+import { dateOnlyStringSchema } from './misc/misc-types';
+import { Serialized } from '../utils';
 
 export enum HabitFrequency {
     DAILY = 'daily',

package/src/types/index.ts

@@ -1,7 +1,12 @@
-// export * from './api'
-// export * from './models'
-export * from './new'
-// export * from './auth-tokens'
-export * from './id-types'
-export * from './misc-types'
-export * from './socket-message-types'
+export * from './misc';
+export * from './agenda-types';
+export * from './thoughts-types';
+export * from './habits-types';
+export * from './id-types';
+export * from './people-types';
+export * from './lists-types';
+export * from './notifications-types';
+export * from './auth-types';
+export * from './user-types';
+export * from './program-config-types';
+export * from './misc';

package/src/types/{new/lists-types.ts → lists-types.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { listIdSchema, listItemIdSchema, userIdSchema } from '../id-types';
-import { Serialized } from '../../utils';
+import { listIdSchema, listItemIdSchema, userIdSchema } from './id-types';
+import { Serialized } from '../utils';
 
 export enum ListType {
     TASKS = 'tasks',

package/src/types/misc/index.ts

@@ -0,0 +1,3 @@
+export * from './misc-types';
+export * from './socket-message-types';
+export * from './version-types';

package/src/types/{new/notifications-types.ts → notifications-types.ts}

@@ -1,16 +1,44 @@
 import { z } from 'zod';
-import { notificationTemplateIdSchema, notificationInstanceIdSchema, userIdSchema } from '../id-types';
-import { Serialized } from '../../utils';
+import { notificationTemplateIdSchema, notificationInstanceIdSchema, userIdSchema } from './id-types';
+import { Serialized } from '../utils';
+
+export interface NotificationContext<T = any> {
+    entityId: string;
+    entityType: NotificationEntityType;
+    entityData: T;
+    userId: string;
+    variables: Record<string, any>;
+}
+
+export enum NotificationEntityType {
+    AGENDA = 'agenda',
+    TASKS = 'tasks', 
+    HABITS = 'habits',
+    INBOX = 'inbox',
+    AGENDA_ITEM = 'agenda_item',
+    HABIT = 'habit',
+    AGENDA_DEFAULTS = 'agenda_defaults',
+    HABITS_DEFAULTS = 'habits_defaults',
+    INBOX_PANEL = 'inbox_panel'
+}
 
-export const notificationEntityTypeSchema = z.enum([
-    'agenda', 'tasks', 'habits', 'inbox',
-    'agenda_item', 'habit',
-    'agenda_defaults', 'habits_defaults'
-]);
+export const notificationEntityTypeSchema = z.nativeEnum(NotificationEntityType);
 
-export const notificationStatusSchema = z.enum(['scheduled', 'sent', 'failed', 'cancelled']);
+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 notificationTriggerTypeSchema = z.enum(['time_based', 'event_based', 'recurring']);
+export const notificationStatusSchema = z.nativeEnum(NotificationStatus);
+export const notificationTriggerTypeSchema = z.nativeEnum(NotificationTriggerType);
 
 export const notificationTriggerSchema = z.object({
     type: notificationTriggerTypeSchema,
@@ -130,9 +158,17 @@ export const getNotificationInstancesRequestSchema = z.object({
     offset: z.number().optional()
 });
 
-export type NotificationEntityType = z.infer<typeof notificationEntityTypeSchema>;
-export type NotificationTriggerType = z.infer<typeof notificationTriggerTypeSchema>;
-export type NotificationStatus = z.infer<typeof notificationStatusSchema>;
+export const entitySyncRequestSchema = z.object({
+    entityType: z.string(),
+    entityId: z.string(),
+    synced: z.boolean()
+});
+
+export const getEntitySyncRequestSchema = z.object({
+    entityType: z.string(),
+    entityId: z.string()
+});
+
 export type NotificationTrigger = z.infer<typeof notificationTriggerSchema>;
 export type NotificationContent = z.infer<typeof notificationContentSchema>;
 export type NotificationTemplateData = z.infer<typeof notificationTemplateSchema>;
@@ -145,6 +181,8 @@ export type UpdateNotificationTemplateRequest = z.infer<typeof updateNotificatio
 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>;
 
 export interface CreateNotificationTemplateResponse {
     template: Serialized<NotificationTemplateData>;
@@ -182,4 +220,18 @@ export interface GetNotificationInstancesResponse {
     instances?: Serialized<NotificationInstanceData>[];
     total?: number;
     error?: string;
+}
+
+export interface EntitySyncResponse {
+    success: boolean;
+    synced: boolean;
+    templates?: Serialized<NotificationTemplateData>[];
+    error?: string;
+}
+
+export interface GetEntitySyncResponse {
+    success: boolean;
+    synced: boolean;
+    hasParentTemplates: boolean;
+    error?: string;
 }

package/src/types/{new/people-types.ts → people-types.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { personIdSchema, personNoteIdSchema, userIdSchema } from '../id-types';
-import { Serialized } from '../../utils';
+import { personIdSchema, personNoteIdSchema, userIdSchema } from './id-types';
+import { Serialized } from '../utils';
 
 export const personPropertySchema = z.object({
     key: z.string(),

package/src/types/{new/thoughts-types.ts → thoughts-types.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { thoughtIdSchema, userIdSchema } from '../id-types';
-import { Serialized } from '../../utils';
+import { thoughtIdSchema, userIdSchema } from './id-types';
+import { Serialized } from '../utils';
 
 export const thoughtSchema = z.object({
     _id: thoughtIdSchema,

package/src/types/{new/user-types.ts → user-types.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { userIdSchema } from '../id-types';
-import { Serialized } from '../../utils';
-import { ModuleType } from '../../enums';
+import { userIdSchema } from './id-types';
+import { Serialized } from '../utils';
+import { ModuleType } from '../enums';
 
 export const moduleSchema = z.object({
     type: z.nativeEnum(ModuleType),

package/src/types/new/index.ts

@@ -1,10 +0,0 @@
-export * from './agenda-types';
-export * from './thoughts-types';
-export * from './habits-types';
-export * from './people-types';
-export * from './lists-types';
-export * from './notifications-types';
-export * from './auth-types';
-export * from './user-types';
-export * from './program-config-types';
-export * from './misc';

package/src/types/new/misc/index.ts

@@ -1 +0,0 @@
-export * from './version-types';

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

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

package/src/types/old/api/account/index.ts

@@ -1,2 +0,0 @@
-export * from './get-user-types';
-export * from './update-user-types';

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

@@ -1,14 +0,0 @@
-import { z } from "zod";
-import { UserData, userDataSchema } from "../../models";
-import { Serialized } from "../../../../utils";
-
-export const updateUserRequestSchema = userDataSchema
-    .omit({ _id: true, createdAt: true, updatedAt: true })
-    .deepPartial()
-    .strict();
-
-export type UpdateUserRequest = z.infer<typeof updateUserRequestSchema>;
-
-export interface UpdateUserResponse {
-    user: Serialized<UserData>;
-}

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

@@ -1,17 +0,0 @@
-import { z } from "zod";
-import { UserId } from "../../../id-types";
-
-export const createAccountRequestSchema = z.object({
-    name: z.string().trim().min(1),
-    email: z.string().trim().email(),
-    password: z.string().min(4),
-    skipVerificationEmail: z.boolean().optional()
-});
-
-export type CreateAccountRequest = z.infer<typeof createAccountRequestSchema>;
-
-export interface CreateAccountResponse {
-    id: UserId;
-    name: string;
-    email: string;
-}

package/src/types/old/api/auth/index.ts

@@ -1,5 +0,0 @@
-export * from './sign-in-types'
-export * from './refresh-auth-types'
-export * from './create-account-types'
-export * from './resend-verification-types'
-export * from './verify-email-types'

package/src/types/old/api/auth/refresh-auth-types.ts

@@ -1,14 +0,0 @@
-import { z } from "zod";
-import { AuthTokens } from "../../auth-tokens";
-import { PublicAuthData } from "../../models";
-
-export const refreshAuthRequestSchema = z.object({
-    refreshToken: z.string()
-});
-
-export type RefreshAuthRequest = z.infer<typeof refreshAuthRequestSchema>;
-
-export interface RefreshAuthResponse {
-    tokenData: AuthTokens;
-    authData: PublicAuthData;
-}

package/src/types/old/api/auth/resend-verification-types.ts

@@ -1,3 +0,0 @@
-export interface ResendVerificationResponse {
-    sent: boolean;
-}

package/src/types/old/api/auth/sign-in-types.ts

@@ -1,16 +0,0 @@
-import { z } from "zod";
-import { AuthTokens } from "../../auth-tokens";
-import { PublicAuthData, UserData } from "../../models";
-
-export const signInRequestSchema = z.object({
-    email: z.string().email(),
-    password: z.string()
-});
-
-export type SignInRequest = z.infer<typeof signInRequestSchema>;
-
-export interface SignInResponse {
-    tokenData: AuthTokens;
-    authData: PublicAuthData;
-    user: UserData;
-}

package/src/types/old/api/auth/verify-email-types.ts

@@ -1,3 +0,0 @@
-export interface VerifyEmailQuery {
-    token?: string;
-}

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

@@ -1,15 +0,0 @@
-import { z } from "zod";
-import { Habit, HabitEntryStatus } from "../../models";
-import { dateOnlyStringSchema } from "../../../misc-types";
-import { Serialized } from "../../../../utils";
-
-export const createHabitEntryRequestSchema = z.object({
-    date: dateOnlyStringSchema,
-    status: z.nativeEnum(HabitEntryStatus)
-});
-
-export type CreateHabitEntryRequest = z.infer<typeof createHabitEntryRequestSchema>;
-
-export interface CreateHabitEntryResponse {
-    habit: Serialized<Habit>;
-}