repovych

Repository universal and composable abstractions and Static realizations of them for quick testing.

Abstractions:

export interface IDeletovich<Id> {
    delete(ids: Id[]): Promise<void>
}

export interface IQueriovich<T, Q> {
    query(q: Q): Promise<T>
}

export interface ISaveovich<T> {
    save(d: T): Promise<void>
}

export interface IResetovych<T> {
    reset(d: T): Promise<void>;
}

export interface ICountovych<T, Q> {
    count(q: Q): Promise<number>;
}

export interface IRepovich<T extends Id, Q, Id extends {}> extends
    IQueriovich<T[], Q>,
    ISaveovich<T[]>,
    IDeletovich<Id> {
        queryDelete(q: Q): Promise<void>
    }

export interface IRepovich2<T extends Id, Q, Id extends {}> extends
    IQueriovich<T[], Q>,
    ISaveovich<T[]>,
    IResetovych<T[]>,
    ICountovych<T[], Q>,
    IDeletovich<Id> {
        queryDelete(q: Q): Promise<void>;
        queryIds(q: Q): Promise<Id[]>;
    }

Static Repovich

export class StaticRepovich<T extends Id, Q, Id extends {}> implements IRepovich<T, Q, Id>
{
    public constructor(
        filterFn: (d: T[], q: Q) => T[],
        getIds: (d: T) => Id
    );

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

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

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

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

}

Static Repovich2

export class StaticRepovich2<T extends Id, Q, Id extends {}> implements IRepovich2<T, Q, Id>
{
    public constructor(
        filterFn: (d: T[], q: Q) => T[],
        idKeys: (keyof Id)[]
    );

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

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

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

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

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

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

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

Static Repovich Example:

type TestRec = {
    id: number,
    val: string,
}

type TestQuery = {
    ids: number[],
    vals: string[],
}

const repo = new StaticRepovich<TestRec, Partial<TestQuery>, {id: number}>(
    (d, q) => {
        if(q.ids) {
            d = d.filter(v => q.ids.includes(v.id));
        }
        if(q.vals) {
            d = d.filter(v => q.vals.includes(v.val));
        }
        return d;
    },
    (d) => d
);
const init: TestRec[] = [
    {id: 1, val: "a"},
    {id: 2, val: "b"},
    {id: 3, val: "a"},
    {id: 4, val: "c"},
];
await repo.save(init);
const res1 = await repo.query({});
assert.deepStrictEqual(res1, init);

const res2 = await repo.query({vals: ["a"]});
assert.deepStrictEqual(res2, [init[0], init[2]]);

await repo.delete([init[2]]);
const res3 = await repo.query({});
assert.deepStrictEqual(res3, [init[0], init[1], init[3]]);

Author

Anatoly Starodubtsev [email protected]

License

MIT