@timothyw/pat-common 1.0.113 → 1.0.115

package/dist/types/old/models/user-data.d.ts

@@ -0,0 +1,147 @@
+import { z } from "zod";
+import { ModuleType } from "../../../enums";
+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 userDataSchema: 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 type Module = z.infer<typeof moduleSchema>;
+export type UserData = z.infer<typeof userDataSchema>;
+export {};

package/dist/types/old/models/user-data.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userDataSchema = void 0;
+const zod_1 = require("zod");
+const id_types_1 = require("../../id-types");
+const enums_1 = require("../../../enums");
+const moduleSchema = zod_1.z.object({
+    type: zod_1.z.nativeEnum(enums_1.ModuleType),
+    visible: zod_1.z.boolean()
+});
+const deviceSchema = zod_1.z.object({
+    pushToken: zod_1.z.string()
+});
+exports.userDataSchema = 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(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;
+        }
+    }, { message: "Invalid timezone" }),
+    config: zod_1.z.object({
+        modules: zod_1.z.array(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())
+        }),
+    })
+});

package/dist/utils/index.d.ts

@@ -1,2 +1,3 @@
 export * from './date-utils';
 export * from './serializing-utils';
+export * from './type-helpers';

package/dist/utils/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./date-utils"), exports);
 __exportStar(require("./serializing-utils"), exports);
+__exportStar(require("./type-helpers"), exports);

package/dist/utils/type-helpers.d.ts

@@ -0,0 +1,4 @@
+import { AuthData, PublicAuthData } from '../types';
+import { HabitData, HabitEntryData, HabitStats, Habit } from '../types';
+export declare function toPublicAuthData(data: AuthData): PublicAuthData;
+export declare const toHabit: (data: HabitData, entries: HabitEntryData[], stats: HabitStats) => Habit;

package/dist/utils/type-helpers.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHabit = void 0;
+exports.toPublicAuthData = toPublicAuthData;
+// export type PublicAuthData = Pick<AuthData, 'email' | 'emailVerified'> & { readonly __brand: unique symbol };
+function toPublicAuthData(data) {
+    return {
+        email: data.email,
+        emailVerified: data.emailVerified
+    };
+}
+const toHabit = (data, entries, stats) => {
+    return {
+        ...data,
+        entries,
+        stats
+    };
+};
+exports.toHabit = toHabit;

package/package.json

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

package/src/types/id-types.ts

@@ -24,10 +24,10 @@ export type ListId = string & { readonly __brand: "ListId" };
 export const listItemIdSchema = z.string().transform((val): ListItemId => val as ListItemId);
 export type ListItemId = string & { readonly __brand: "ListItemId" };
 
-export const habitIdSchema = z.string().transform((val): ListId => val as ListId);
+export const habitIdSchema = z.string().transform((val): HabitId => val as HabitId);
 export type HabitId = string & { readonly __brand: "HabitId" };
 
-export const habitEntryIdSchema = z.string().transform((val): ListId => val as ListId);
+export const habitEntryIdSchema = z.string().transform((val): HabitEntryId => val as HabitEntryId);
 export type HabitEntryId = string & { readonly __brand: "HabitEntryId" };
 
 export const notificationTemplateIdSchema = z.string().transform((val): NotificationTemplateId => val as NotificationTemplateId);

package/src/types/index.ts

@@ -1,6 +1,7 @@
-export * from './api'
-export * from './models'
-export * from './auth-tokens'
+// 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'

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

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { itemIdSchema, userIdSchema } from '../id-types';
+import { Serialized } from '../../utils';
+
+export const agendaItemSchema = z.object({
+    _id: itemIdSchema,
+    userId: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    name: z.string().min(1),
+    dueDate: z.date().optional(),
+    notes: z.string().optional(),
+    completed: z.boolean(),
+    urgent: z.boolean(),
+    category: z.string().optional(),
+    type: z.string().optional()
+});
+
+export const createAgendaItemRequestSchema = z.object({
+    name: z.string().min(1),
+    dueDate: z.string().optional(),
+    notes: z.string().optional(),
+    urgent: z.boolean().optional().default(false),
+    category: z.string().optional(),
+    type: z.string().optional()
+});
+
+export const updateAgendaItemRequestSchema = z.object({
+    name: z.string().min(1).optional(),
+    dueDate: z.string().nullish(),
+    notes: z.string().nullish(),
+    urgent: z.boolean().optional(),
+    category: z.string().nullish(),
+    type: z.string().nullish()
+});
+
+export const completeAgendaItemRequestSchema = z.object({
+    completed: z.boolean()
+});
+
+export type AgendaItemData = z.infer<typeof agendaItemSchema>;
+
+export type CreateAgendaItemRequest = z.infer<typeof createAgendaItemRequestSchema>;
+export type UpdateAgendaItemRequest = z.infer<typeof updateAgendaItemRequestSchema>;
+export type CompleteAgendaItemRequest = z.infer<typeof completeAgendaItemRequestSchema>;
+
+export interface CreateAgendaItemResponse {
+    agendaItem: Serialized<AgendaItemData>;
+}
+
+export interface GetAgendaItemsResponse {
+    agendaItems: Serialized<AgendaItemData>[];
+}
+
+export interface GetAgendaItemResponse {
+    agendaItem: Serialized<AgendaItemData>;
+}
+
+export interface UpdateAgendaItemResponse {
+    agendaItem: Serialized<AgendaItemData>;
+}
+
+export interface CompleteAgendaItemResponse {
+    agendaItem: Serialized<AgendaItemData>;
+}
+
+export interface DeleteAgendaItemResponse {
+    deleted: boolean;
+}

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

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+import { authIdSchema, userIdSchema } from '../id-types';
+
+export const authTokensSchema = z.object({
+    accessToken: z.string(),
+    refreshToken: z.string()
+});
+
+export const tokenPayloadSchema = z.object({
+    authId: z.string(),
+    userId: z.string()
+});
+
+export const refreshTokenPayloadSchema = tokenPayloadSchema.extend({
+    tokenId: z.string()
+});
+
+export const authDataSchema = z.object({
+    _id: authIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    userId: userIdSchema,
+    email: z.string(),
+    passwordHash: z.string(),
+    emailVerified: z.boolean()
+});
+
+export const publicAuthDataSchema = z.object({
+    email: z.string(),
+    emailVerified: z.boolean()
+});
+
+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 const signInRequestSchema = z.object({
+    email: z.string().email(),
+    password: z.string()
+});
+
+export const refreshAuthRequestSchema = z.object({
+    refreshToken: z.string()
+});
+
+export const resendVerificationRequestSchema = z.object({
+    email: z.string().email()
+});
+
+export const verifyEmailQuerySchema = z.object({
+    token: z.string().optional()
+});
+
+export type AuthTokens = z.infer<typeof authTokensSchema>;
+export type TokenPayload = z.infer<typeof tokenPayloadSchema>;
+export type RefreshTokenPayload = z.infer<typeof refreshTokenPayloadSchema>;
+export type AuthData = z.infer<typeof authDataSchema>;
+export type PublicAuthData = z.infer<typeof publicAuthDataSchema> & { readonly __brand: unique symbol };
+
+export type CreateAccountRequest = z.infer<typeof createAccountRequestSchema>;
+export type SignInRequest = z.infer<typeof signInRequestSchema>;
+export type RefreshAuthRequest = z.infer<typeof refreshAuthRequestSchema>;
+export type ResendVerificationRequest = z.infer<typeof resendVerificationRequestSchema>;
+export type VerifyEmailQuery = z.infer<typeof verifyEmailQuerySchema>;
+
+export interface CreateAccountResponse {
+    id: string;
+    name: string;
+    email: string;
+}
+
+export interface SignInResponse {
+    tokenData: AuthTokens;
+    authData: PublicAuthData;
+    user: any;
+}
+
+export interface RefreshAuthResponse {
+    tokenData: AuthTokens;
+    authData: PublicAuthData;
+}
+
+export interface ResendVerificationResponse {
+    sent: boolean;
+}
+
+export interface VerifyEmailResponse {
+    verified: boolean;
+}

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

@@ -0,0 +1,112 @@
+import { z } from 'zod';
+import { habitIdSchema, habitEntryIdSchema, userIdSchema } from '../id-types';
+import { dateOnlyStringSchema } from '../misc-types';
+import { Serialized } from '../../utils';
+
+export enum HabitFrequency {
+    DAILY = 'daily',
+    WEEKLY = 'weekly',
+    EVERY_N_DAYS = 'every_n_days',
+    WEEKDAYS_ONLY = 'weekdays_only',
+    CUSTOM = 'custom'
+}
+
+export enum HabitEntryStatus {
+    COMPLETED = 'completed',
+    EXCUSED = 'excused',
+    MISSED = 'missed'
+}
+
+export const habitEntrySchema = z.object({
+    _id: habitEntryIdSchema,
+    habitId: habitIdSchema,
+    userId: userIdSchema,
+    date: dateOnlyStringSchema,
+    status: z.nativeEnum(HabitEntryStatus),
+    createdAt: z.date(),
+    updatedAt: z.date()
+});
+
+export const habitDataSchema = z.object({
+    _id: habitIdSchema,
+    userId: userIdSchema,
+    name: z.string(),
+    description: z.string().nullable().optional(),
+    notes: z.string().nullable().optional(),
+    frequency: z.nativeEnum(HabitFrequency),
+    rolloverTime: z.string(),
+    firstDay: dateOnlyStringSchema,
+    createdAt: z.date(),
+    updatedAt: z.date()
+});
+
+export const habitStatsSchema = z.object({
+    totalDays: z.number(),
+    completedDays: z.number(),
+    excusedDays: z.number(),
+    missedDays: z.number(),
+    completionRate: z.number()
+});
+
+export const habitSchema = habitDataSchema.extend({
+    entries: z.array(habitEntrySchema),
+    stats: habitStatsSchema
+});
+
+export const createHabitRequestSchema = z.object({
+    name: z.string().min(1).trim(),
+    description: z.string().trim().optional(),
+    notes: z.string().trim().optional(),
+    frequency: z.nativeEnum(HabitFrequency),
+    rolloverTime: z.string().regex(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/)
+});
+
+export const updateHabitRequestSchema = z.object({
+    name: z.string().min(1).trim().optional(),
+    description: z.string().trim().nullish(),
+    notes: z.string().trim().nullish(),
+    frequency: z.nativeEnum(HabitFrequency).optional(),
+    rolloverTime: z.string().regex(/^([01]?[0-9]|2[0-3]):[0-5][0-9]$/).optional()
+});
+
+export const createHabitEntryRequestSchema = z.object({
+    date: dateOnlyStringSchema,
+    status: z.nativeEnum(HabitEntryStatus)
+});
+
+export type HabitEntryData = z.infer<typeof habitEntrySchema>;
+export type HabitData = z.infer<typeof habitDataSchema>;
+export type HabitStats = z.infer<typeof habitStatsSchema>;
+export type Habit = z.infer<typeof habitSchema>;
+
+export type CreateHabitRequest = z.infer<typeof createHabitRequestSchema>;
+export type UpdateHabitRequest = z.infer<typeof updateHabitRequestSchema>;
+export type CreateHabitEntryRequest = z.infer<typeof createHabitEntryRequestSchema>;
+
+export interface CreateHabitResponse {
+    habit: Serialized<Habit>;
+}
+
+export interface GetHabitsResponse {
+    habits: Serialized<Habit>[];
+}
+
+export interface GetHabitResponse {
+    habit: Serialized<Habit>;
+}
+
+export interface UpdateHabitResponse {
+    habit: Serialized<Habit>;
+}
+
+export interface DeleteHabitResponse {
+    deleted: boolean;
+}
+
+export interface CreateHabitEntryResponse {
+    habit: Serialized<Habit>;
+}
+
+export interface DeleteHabitEntryResponse {
+    habit: Serialized<Habit>;
+}

package/src/types/new/index.ts

@@ -0,0 +1,10 @@
+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/lists-types.ts

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { listIdSchema, listItemIdSchema, userIdSchema } from '../id-types';
+import { Serialized } from '../../utils';
+
+export enum ListType {
+    TASKS = 'tasks',
+    NOTES = 'notes'
+}
+
+export const listItemSchema = z.object({
+    _id: listItemIdSchema,
+    userId: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    name: z.string(),
+    notes: z.string().optional(),
+    completed: z.boolean(),
+    listId: listIdSchema
+});
+
+export const listSchema = z.object({
+    _id: listIdSchema,
+    userId: userIdSchema,
+    createdAt: z.date(),
+    updatedAt: z.date(),
+    name: z.string(),
+    type: z.nativeEnum(ListType)
+});
+
+export const createListRequestSchema = z.object({
+    name: z.string().min(1),
+    type: z.nativeEnum(ListType)
+});
+
+export const updateListRequestSchema = z.object({
+    name: z.string().min(1).optional(),
+    type: z.nativeEnum(ListType).optional()
+});
+
+export const createListItemRequestSchema = z.object({
+    name: z.string().min(1),
+    notes: z.string().optional(),
+    listId: listIdSchema
+});
+
+export const updateListItemRequestSchema = z.object({
+    name: z.string().min(1).optional(),
+    notes: z.string().nullish(),
+    completed: z.boolean().optional(),
+    listId: listIdSchema.optional()
+});
+
+export const completeListItemRequestSchema = z.object({
+    completed: z.boolean()
+});
+
+export type ListItemData = z.infer<typeof listItemSchema>;
+export type ListData = z.infer<typeof listSchema>;
+
+export type CreateListRequest = z.infer<typeof createListRequestSchema>;
+export type UpdateListRequest = z.infer<typeof updateListRequestSchema>;
+export type CreateListItemRequest = z.infer<typeof createListItemRequestSchema>;
+export type UpdateListItemRequest = z.infer<typeof updateListItemRequestSchema>;
+export type CompleteListItemRequest = z.infer<typeof completeListItemRequestSchema>;
+
+export interface CreateListResponse {
+    list: Serialized<ListData>;
+}
+
+export interface GetListsResponse {
+    lists: Serialized<ListData>[];
+}
+
+export interface GetListResponse {
+    list: Serialized<ListData>;
+}
+
+export interface UpdateListResponse {
+    list: Serialized<ListData>;
+}
+
+export interface DeleteListResponse {
+    deleted: boolean;
+}
+
+export interface CreateListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+
+export interface GetListItemsResponse {
+    listItems: Serialized<ListItemData>[];
+}
+
+export interface GetListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+
+export interface UpdateListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+
+export interface CompleteListItemResponse {
+    listItem: Serialized<ListItemData>;
+}
+
+export interface DeleteListItemResponse {
+    deleted: boolean;
+}

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

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

package/src/types/new/misc/version-types.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+export const versionQuerySchema = z.object({
+    iOSBuildVersion: z.number().optional(),
+    androidBuildVersion: z.number().optional()
+});
+
+export const versionResponseSchema = z.object({
+    minIOSBuildVersion: z.number(),
+    minAndroidBuildVersion: z.number(),
+    updateRequired: z.boolean()
+});
+
+export type VersionQuery = z.infer<typeof versionQuerySchema>;
+export type VersionResponse = z.infer<typeof versionResponseSchema>;