Can't generate Typescript declarations for List<...>

[kieranm]

Apologies if I'm doing something dumb here, I'm super new to this. I can't get it to export List<...> Typescript declarations correctly.

The plugin config is:

suspendTransformPlugin {
    transformers {
        addJsPromise {
            addCopyAnnotationExclude {
                // `kotlinJsExportIgnoreClassInfo` is a ClassInfo defined in advance.
                // You can also choose to use `packageName` and `className` directly.
                from(SuspendTransformConfigurations.kotlinJsExportIgnoreClassInfo)
            }
        }
    }
}

I have this code

...

@OptIn(ExperimentalJsExport::class)
@JsExport
data class Event(
    val id: String,
    val title: String,
    val startTs: Double,
    val endTs: Double
) {
    companion object {
        @JsExport.Ignore
        fun fromDb(e: DBEvent): Event =
            Event(e.id, e.title, e.start_ts, e.end_ts)
    }

    @JsExport.Ignore
    fun toDb(): DBEvent =
        DBEvent(id, title, startTs, endTs)
}

@OptIn(ExperimentalJsExport::class)
@JsExport
class EventsRepository(
    private val db: SyncDatabase
) {
    @JsExport.Ignore
    @JsPromise
    suspend fun listEvents(): List<Event> =
        db.eventQueries.listAll().awaitAsList().map(Event::fromDb)

    @JsPromise
    @JsExport.Ignore
    suspend fun getEventById(id: String): Event? =
        db.eventQueries.getById(id).awaitAsOneOrNull()?.let(Event::fromDb)
...
}

In the generated typescript, Promise<Any> is generated as the return type of listEventsAsync.

export declare class EventsRepository {
    constructor(db: any/* SyncDatabase */);
    getEventByIdAsync(id: string): Promise<Nullable<Event>>;
    updateTitleAsync(id: string, title: string): Promise<void>;
    listEventsAsync(): Promise<any/* KtList<Event> */>;
    insertAsync(id: string, title: string, startTs: number, endTs: number): Promise<void>;
    upsertAsync(id: string, title: string, startTs: number, endTs: number): Promise<void>;
    deleteAsync(id: string): Promise<void>;
}

If I add a test function as follows to the class, without any decorations...

fun test(): List<Event> {
        // No-op
        return emptyList()
    }

It exports the correct types, and also fixes the type in other places!

export declare class EventsRepository {
    constructor(db: any/* SyncDatabase */);
    test(): KtList<Event>;
    getEventByIdAsync(id: string): Promise<Nullable<Event>>;
    updateTitleAsync(id: string, title: string): Promise<void>;
    listEventsAsync(): Promise<KtList<Event>>;
    insertAsync(id: string, title: string, startTs: number, endTs: number): Promise<void>;
    upsertAsync(id: string, title: string, startTs: number, endTs: number): Promise<void>;
    deleteAsync(id: string): Promise<void>;
}

Would anybody be able to help me understand what I'm doing wrong here and how to fix this properly? Thanks!

[ForteScarlet]

Under the conditions of kt 2.2.20 + plugin 2.2.20--0.13.1, I conducted testing using the following simple code:

@file:OptIn(ExperimentalJsExport::class)

import love.forte.plugin.suspendtrans.annotation.JsPromise

@JsExport
class DBEvent

@OptIn(ExperimentalJsExport::class)
@JsExport
data class Event(
    val id: String,
    val title: String,
    val startTs: Double,
    val endTs: Double
) {
    companion object {
        @JsExport.Ignore
        fun fromDb(e: DBEvent): Event =
            TODO()
    }

    @JsExport.Ignore
    fun toDb(): DBEvent =
        TODO()
}

@OptIn(ExperimentalJsExport::class)
@JsExport
class EventsRepository(
    private val db: Any
) {
    @JsExport.Ignore
    @JsPromise
    suspend fun listEvents(): List<Event> =
        emptyList()

    @JsPromise
    @JsExport.Ignore
    suspend fun getEventById(id: String): Event? = null
}

The resulting d.ts file is as follows:

type Nullable<T> = T | null | undefined
declare function KtSingleton<T>(): T & (abstract new() => any);
export declare class DBEvent {
    constructor();
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace DBEvent.$metadata$ {
    const constructor: abstract new () => DBEvent;
}
export declare class Event {
    constructor(id: string, title: string, startTs: number, endTs: number);
    get id(): string;
    get title(): string;
    get startTs(): number;
    get endTs(): number;
    copy(id?: string, title?: string, startTs?: number, endTs?: number): Event;
    toString(): string;
    hashCode(): number;
    equals(other: Nullable<any>): boolean;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace Event.$metadata$ {
    const constructor: abstract new () => Event;
}
export declare namespace Event {
    abstract class Companion extends KtSingleton<Companion.$metadata$.constructor>() {
        private constructor();
    }
    /** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
    namespace Companion.$metadata$ {
        abstract class constructor {
            private constructor();
        }
    }
}
export declare class EventsRepository {
    constructor(db: any);
    getEventByIdAsync(id: string): Promise<Nullable<Event>>;
    listEventsAsync(): Promise<KtList<Event>>;
}
/** @deprecated $metadata$ is used for internal purposes, please don't use it in your code, because it can be removed at any moment */
export declare namespace EventsRepository.$metadata$ {
    const constructor: abstract new () => EventsRepository;
}

The listEventsAsync(): Promise<KtList<Event>>; in the ts file I received is normal.

You can try this: without using the compiler plugin, manually define a function that returns a Promise<List<String>>, then export it, and see if the same issue occurs.

My guess: This might be a Kotlin bug that was fixed in version 2.2.20.

[kieranm]

Thank you! I'm on 2.2.10 right now so I'll upgrade and report back