chorus/src/types.ts

import {z} from "zod";

const commentsConfigSchema = z.object({
    mail: z.object({
        imap: z.object({
            host: z.string(),
            port: z.number({ coerce: true }),
            auth: z.object({
                user: z.string(),
                pass: z.string(),
            }),
        }),
        threads: z.object({
            type: z.string(),  // fixme : in validation
            template: z.string(),
            idPrefix: z.string(),
            replyPrefix: z.string(),
        }),
    }),
    dirs: z.object({
        data: z.string(),
    }),
})

export type CommentsConfig = z.infer<typeof commentsConfigSchema>
export const castCommentsConfig = (what: unknown): CommentsConfig => {
    return commentsConfigSchema.parse(what)
}



export type Message = {
    id: string,
    idHash: string,
    date: Date,
    recipients: string[],
    from: {
        name?: string,
        address?: string,
    },
    subject: string,
    content: string,
    html?: string,
    mailbox: string,
    modseq: BigInt,
    thread?: string,
    replyToHash?: string,
}

export type ThreadUser = {
    name: string,
    mailId: string,
    domainId: string,
    color: string,
}

export type ThreadComment = {
    idHash: string,
    replyToHash?: string,
    replyAddress: string,
    user: ThreadUser,
    date: Date,
    subject: string,
    text: string,
    rendered: string,
    replies?: ThreadComment[],
}

export type ThreadData = {
    thread: string,
    refresh: {
        date: Date,
        markers: {[key: string]: BigInt},
    },
    comments: ThreadComment[],
}

export type RootData = {
    refresh?: {
        date: Date,
    },
}