repovych-knex

Knex realization of Repovych reposytory abstraction (see https://gitflic.ru/project/pantagruel74/repovych)

Example of usage

//class-model. see https://gitflic.ru/project/pantagruel74/class-model
const UserRecord {
    @property(null,
        valid.number(),
        make.int()
    )
    id: number;

    @property(null,
        valid.string(s => !!s.length),
        make.string()
    )
    name: string;
}

type UserQuery = {
    ids: number[],
}

const conn KnexovychConnection.createMysql({
    host: '127.0.0.1',
    port: 3306,
    user: 'your_database_user',
    password: 'your_database_password',
    database: 'myapp_test',
});

const log = new ConsoleLoggych();

const migration = new KnexovychMigrationManager(conn, log);
await migration.lastest();

const repo: IRepovych<UserRecord, Partial<UserQuery>, {id: string}> = 
    new RepovychKnexovych(
        conn,
        "users",
        (q, k) => (!!q.ids) ? k.whereIn("id", q.ids) : k,
        () => new UserRecord(),
        log
    );

await repo.save([{id: 1, name: "admin"}, {id: 2, name: "guest"}]);
const result = await repo.query({ids: [2]});
console.log(result); //=> [{id: 2, name: "guest"}]

API

Connection:

export type MigrationsConf = {
    extension: string,
    directory: string,
    stub?: string,
    tableName?: string,
    schemaName?: string,
    disableTransactions?: boolean,
    disableMigrationsListValidation?: boolean,
    sortDirsSeparately?: boolean,
    loadExtensions?: string[],
    migrationSource?: any,
}

export type SeedsConf = {
    directory: string,
    extension: string,
    loadExtensions?: string,
    recursive?: boolean,
    specific?: any,
    sortDirsSeparately?: boolean,
    seedSource?: any,
    timestampFilenamePrefix?: any,
}

export class KnexovychConnection
{
    //Agile constructor by knex config. Special costructors in static methods
    public constructor(conf: any);

    public runInConnection(f: (k: Knex) => Promise<any>, timeout = 10000): Promise<any>;

    public runInTransaction(f: (k: Knex) => (Knex.QueryBuilder|Promise<any>), timeout = 10000): Promise<any>;

    public updateConnection();

    public updateConnectionIfExpired(expiredMsDiff: number);

    public updateConnectionLater(delayMs: number = 5000);

    public shutdown();

    private static makeKnexovichConnection(
        client: string,
        conn: any,
        migrations: MigrationsConf|null, 
        seeds: SeedsConf|null,
        pool: {min: number, max: number}|null,
        extra: {}
    ): KnexovychConnection;

    public static createMysql(conn: {
            host: string,
            port: number,
            user: string,
            password: string,
            database: string,
        }, 
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createOracledb(conn: {
            host: string,
            port?: number,
            user: string,
            password: string,
            database: string,
            odbc?: string
        }, 
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createMssql(conn: {
            server: string,
            port: number,
            user: string,
            password: string,
            database: string,
        }, 
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createSqlite(conn: {
            filename: string,
            flags?: string[],
            options?: any,
        },
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createSqlite3(conn: {
            filename: string,
            flags?: string[],
            options?: any,
        },
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createBetterSqlite3(conn: {
            filename: string,
            flags?: string[],
            options?: any,
        },
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createPgSearchPath(conn: {
            searchPath: string[],
        },
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createPg(conn: {
            connectionString: string,
            host: string,
            port: number,
            user: string,
            database: string,
            password: string,
            ssl?: any,
        },
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;

    public static createPostgres(conn: {
            connectionString: string,
            host: string,
            port: number,
            user: string,
            database: string,
            password: string,
            ssl?: any,
        },
        migrations: MigrationsConf|null = null, 
        seeds: SeedsConf|null = null,
        version: string|null = null,
        pool: {min: number, max: number}|null = null
    ): KnexovychConnection;
}

Migration:

export class KnexovychMigrationManager
{
    public constructor(conn: KnexovychConnection, log: ILoggych);

    public async make(name: string): Promise<void>;

    public async up(): Promise<void>;

    public async down(): Promise<void>;

    public async lastest(): Promise<void>;

    public async rollback(): Promise<void>;
}

Repo:

export class RepovychKnexovych<T extends S, Q, S extends {}> 
    implements IRepovich<T, Q, S> 
{
    public conn: KnexovychConnection;
    public tablename: string;
    public queryProcess: (q: Q, k: Knex.QueryBuilder) => Knex.QueryBuilder;
    public idFields: (keyof S)[];
    public newModel: () => T;
    public log: ILoggych;

    constructor(
        conn: KnexovychConnection, 
        tablename: string, 
        queryProcess: (q: Q, k: Knex.QueryBuilder) => Knex.QueryBuilder,
        idFields: (keyof S)[],
        newModel: () => T,
        log: ILoggych
    );

    public async query(q: Q): Promise<T[]>;

    private getId<A extends S>(v: A): S;

    public async delete(ids: S[]): Promise<void>;

    public async queryDelete(q: Q): Promise<void>;

    public async save(d: T[]): Promise<void>;

    public modify<Q1 extends {}, T2 extends S>(
        queryMod: (q: Q1, k: Knex.QueryBuilder) => Knex.QueryBuilder,
        newModel: () => T2
    ): RepovychKnexovych<T2, Q & Q1, S>;
}

Repov2:

export class RepovychKnexovych2<T extends S, Q, S extends {}> 
    implements IRepovich2<T, Q, S> 
{
    public conn: KnexovychConnection;
    public tablename: string;
    public queryProcess: (q: Q, k: Knex.QueryBuilder) => Knex.QueryBuilder;
    public idFields: (keyof S)[];
    public newModel: () => T;
    public log: ILoggych;

    constructor(
        conn: KnexovychConnection, 
        tablename: string, 
        queryProcess: (q: Q, k: Knex.QueryBuilder) => Knex.QueryBuilder,
        idFields: (keyof S)[],
        newModel: () => T,
        log: ILoggych
    );

    public async query(q: Q): Promise<T[]>;

    private getId<A extends S>(v: A): S;

    public async delete(ids: S[]): Promise<void>;

    public async queryDelete(q: Q): Promise<void>;

    public async save(d: T[]): Promise<void>;

    public modify<Q1 extends {}, T2 extends S>(
        queryMod: (q: Q1, k: Knex.QueryBuilder) => Knex.QueryBuilder,
        newModel: () => T2
    ): RepovychKnexovych<T2, Q & Q1, S>;

    public async count(q: Q): Promise<number>;

    public async reset(d: T[]): Promise<void>;

    public async queryIds(q: Q): Promise<T[]>;
}

Author

Anatoly Starodubtsev [email protected]

License

MIT