tibi-types/index.d.ts

export interface CollectionDocument {
    id?: string
    insertTime?: Date
    updateTime?: Date
    [key: string]: any
}

export interface DbReadOptions {
    filter?: {
        [key: string]: any
    }
    selector?: {
        [key: string]: any
    }
    projection?: string
    offset?: number
    limit?: number
    sort?: string[]
}

interface GetHookGetOnlyData {
    /**
     * true if only one document was requested via /COLLECTION/ID
     */
    one?: boolean
    /**
     * get list of documents (only valid after stage "read" in "get" hook)
     */
    results(): CollectionDocument[]
}

interface GetHookData {
    /**
     * filter map only valid for "get" hooks
     */
    filter?: {
        [key: string]: any
    }
    /**
     * selector map only valid for "get" hooks
     */
    selector?: {
        [key: string]: any
    }
    /**
     * offset only valid for "get" hooks
     */
    offset?: number
    /**
     * limit only valid for "get" hooks
     */
    limit?: number
    /**
     * sort only valid for "get" hooks
     */
    sort?: string[] | string
}

interface PostHookData {
    /**
     * post data only valid in "post" and "put" hooks
     */
    data?: CollectionDocument
}

interface DbPackage {
    /**
     * read results from a collection
     *
     * @param colName collection name
     * @param options options map
     */
    find(
        colName: string,
        options?: DbReadOptions
    ): CollectionDocument[]

    /**
     * read count of documents for filter from a collection
     *
     * @param colName collection name
     * @param options options map (only filter is valid)
     */
    count(
        colName: string,
        options?: DbReadOptions
    ): number

    /**
     * create a document in a collection
     *
     * @param colName collection name
     * @param data data map
     */
    create(
        colName: string,
        data: CollectionDocument
    ): CollectionDocument

    /**
     * update a document in a collection
     *
     * @param colName collection name
     * @param id id of entry
     * @param data new/changed data
     */
    update(
        colName: string,
        id: string,
        data: CollectionDocument
    ): CollectionDocument

    /**
     * deletes one document by id from collection
     *
     * @param colName collection name
     * @param id id of entry
     */
    delete(colName: string, id: string): { message: "ok" }

    /**
     * deletes documents by filter from collection
     *
     * @param colName collection name
     * @param options options map, only filter valid
     */
    deleteMany(
        colName: string,
        options?: DbReadOptions
    ): { message: "ok"; removed: number }

}

interface SmtpPackage {
    /**
     * send an email
     *
     * @param options email options map
     */
    sendMail(options: {
        to: string | string[]
        cc?: string | string[]
        bcc?: string | string[]
        subject?: string
        from: string
        fromName?: string
        replyTo?: string
        plain?: string
        html?: string
        attach?: string | string[]
    }): void
}

interface FsPackage {
    /**
     * read a file relative to config dir and return its content
     *
     * @param path relative file path
     */
    readFile(path: string): string

    /**
     * stat file or directory
     *
     * @param path
     */
    stat(path: string): {
        name: string
        size: number
        isDir: boolean
        modTime: string
    }

    /**
     * list directory entries
     *
     * @param path
     */
    readDir(path: string): {
        name: string
        size: number
        isDir: boolean
        modTime: string
    }[]

    /**
     * make directory and all missing sub directories, no error if directory already exists
     *
     * @param path
     */
    mkDir(path: string): void

    /**
     * remove file or empty directory
     *
     * @param path
     */
    remove(path: string): void

}

interface TplPackage {
    /**
     * execute a template code and return result
     *
     * @param code template code
     * @param contextData template context map
     */
    execute(
        code: string,
        contextData?: {
            [key: string]: any
        }
    ): string
}

interface HttpPackage {
    /**
     * http request
     *
     * @param url url for request
     * @param options request options
     */
    fetch(
        url: string,
        options?: {
            method?: string
            headers?: { [key: string]: string }
            body?: string
        }
    ): {
        status: number
        statusText: string
        headers: { [key: string]: string }
        trailer: { [key: string]: string }
        url: string
        body: {
            text(): string
            json(): any
        }
    }
}

interface DebugPackage {
    /**
     * dumps data to header and server log
     *
     * @param toDump data to dump
     */
    dump(...toDump: any): void

    /**
     * get Sentry trace id
     */
    sentryTraceId(): string
}

interface ResponsePackage {
    /**
     * set response header
     *
     * @param name header name
     * @param value value
     */
    header(name: string, value: any): void
}

interface UserPackage {
    /**
     * get JWT authentication
     */
    auth(): {
        id: string
        username: string
        role: number
        permissions: string[]
    }
}

interface BcryptPackage {
    /**
     * hash password via bcrypt algo
     *
     * @param password clear text password
     * @param options hashing options
     */
    hash(
        password: string,
        options?: {
            cost?: number
        }
    ): string

    /**
     * check password against hashed password via bcrypt algo
     *
     * @param password clear text password
     * @param hash hashed password
     */
    check(password: string, hash: string): boolean
}

interface JwtPackage {
    /**
     * create a jwt signed token string
     *
     * @param claims data object
     * @param options options (secret, validityDuration = expiry in X seconds)
     */
    create(
        claims: {
            [key: string]: any
        },
        options?: {
            secret?: string
            validityDuration?: number
        }
    ): string

    /**
     * parse jwt token string
     *
     * @param token token string
     * @param options options (secret)
     */
    parse(
        token: string,
        options?: {
            secret?: string
        }
    ): {
        error?: string
        valid: boolean
        method: {
            Name: string
            Hash: number
        }
        header: {
            alg: string
            typ: string
        }
        claims: {
            exp?: number
            [key: string]: any
        }
    }
}

interface CharsetPackage {
    /**
     * convert iso8859 to utf8
     *
     * @param iso8859 iso string
     */
    iso8859ToUtf8(iso8859: string): string
}

interface ImagePackage {
    /**
     * convert image from source file to target file with filters
     *
     * @param sourceFile
     * @param targetFile
     * @param filters
     */
    filter(
        sourceFile: string,
        targetFile: string,
        filters: {
            fit?: boolean
            fill?: boolean
            width?: number
            height?: number
            brightness?: number
            saturation?: number
            contrast?: number
            gamma?: number
            blur?: number
            sharpen?: number
            invert?: boolean
            grayscale?: boolean
            quality?: number
        }[]
    ): void
}

interface XmlPackage {
    /**
     * create xml string
     * 
     * @param data object or array
     * @param options options
     */
    create(data: any, options?: {}): string

    /**
     * parse xml string to json
     * 
     * @param xml xml string
     * @param options options
     */
    parse(xml:string, options?: {}): any
}

interface CookiePackage {
    /**
     * get cookie from http header
     * 
     * @param name cookie name
     */
    get(name: string): string

    /**
     * set cookie via http header
     * 
     * @param name cookie name
     * @param value cookie value
     * @param options cookie options
     */
    set(name: string, value: string, options?:{
        maxAge?: number
        path?:string
        domain?:string
        secure?:boolean
        httpOnly?:boolean
    }): void
}

export interface HookContext extends GetHookData, GetHookGetOnlyData, PostHookData {
    request(): {
        method: string
        remoteAddr: string
        host: string
        url: string
        path: string
        param(p: string): string
        query(q: string): string
        header(h: string): string
        body(): string
        /**
         * bodyBytes return []byte go slice of post body for later use pe. in iso8859ToUtf8
         */
        bodyBytes(): string
    }

    db: DbPackage
    smtp: SmtpPackage
    fs: FsPackage
    tpl: TplPackage
    http: HttpPackage
    debug: DebugPackage
    response: ResponsePackage
    user: UserPackage
    bcrypt: BcryptPackage
    jwt: JwtPackage
    charset: CharsetPackage
    image: ImagePackage
    xml: XmlPackage
    cookie: CookiePackage
}

export interface HookException {
    status?: number
    html?: string
    file?: string
    [key: string]: any
}

export interface HookResponse extends GetHookData, PostHookData {
    data?: CollectionDocument
    results?: any
}

declare global {
    var context: HookContext
}