Is there a simpler way to create type safe javascript classes that initialize sequelize models?

I am creating a javascript class that contains several data models, which I am managing with sequelize. The challenge I am facing is that (1) the constructor method cannot be async (as of 4/3/2023), but (2) the sequelize sync and create functions are async (as well they should be as they are accessing a database, and a possibly remote database at that). However, I would like some basic attributes to be passed to the constructor. So my work around is like this:

import type { Config } from '$lib/server/config.js';
import { Model, Sequelize, DataTypes } from 'sequelize';
import type { ModelDefined, InferAttributes, InferCreationAttributes, CreationOptional } from 'sequelize';

class CourseDescription extends Model<InferAttributes<CourseDescription>, InferCreationAttributes<CourseDescription>> {
    declare id: CreationOptional<number>;
    declare name: string;
}

export class Course {
    protected sequelize:Sequelize;
    protected Description:ModelDefined<InferAttributes<CourseDescription>, InferCreationAttributes<CourseDescription>>
    public initComplete:Promise<boolean>;

    constructor(protected config:Config, name: string) {
        this.sequelize = new Sequelize(this.config.postgres_url);
        
        const desc = this.sequelize.define("CourseDescription", 
            {
                id: {
                    type: DataTypes.INTEGER,
                    autoIncrement: true,
                    primaryKey: true
                },
                name: DataTypes.TEXT
            }
        )

        // work around to avoid "used before assigned" error below
        this.Description = desc;

        this.initComplete = (async () => {         
            await desc.sync();
            await desc.create({ name});
            return(true);
        })()
    }
}

Then when I use the class:

import config from './lib/server/config';
import { Course } from './lib/server/course'

const m = new Course(config, "My Excellent Course");
await m.initComplete;

But that seems to me to be an awfully long walk to achieve a relatively simple task. (And also the work around to avoid the "property used before assigned" error from TypeScript is pretty ugly.)

Is there a more parsimonious approach to defining a sequelize model and creating a record via the class constructor?

Taking sequelize out of the equation, a common pattern is to use a private constructor with a factory method to create instances that rely on some asynchronous behavior:

class ClassRequiringAsyncInitialization {
    private constructor(private someProperty: string) {}

    static async create() {
        const someProperty = await new Promise<string>(
            (resolve) => setTimeout(() => resolve('property'))
        );

        return new ClassRequiringAsyncInitialization(someProperty);
    }
}

const x = ClassRequiringAsyncInitialization.create(); // OK, can be awaited
const y = new ClassRequiringAsyncInitialization('property'); // error