@cloud-cli/store/dist/resource.d.ts

Data store abstraction

declare function getMetadataOf(target: any): Map<string | symbol, string | TableColumn>;
declare function getMetadataOf(target: any, property: string | symbol): TableColumn;
export type ColumnType = typeof String | typeof Number | typeof Object | typeof Boolean;
export type ColumnValue = string | number | boolean;
export type ConstructorOf<T> = {
    new (...args: any[]): T;
    prototype: T;
};
export interface TableColumn {
    name: string;
    type: ColumnType;
    unique?: boolean;
    notNull?: boolean;
    primary?: boolean;
    defaultValue?: unknown;
}
export declare function Model(name: string): any;
export declare function NotNull(): any;
export declare function Unique(): any;
export declare function Primary(): any;
export declare function Property(type: ColumnType, defaultValue?: any): any;
declare const operators: {
    is: string;
    isNot: string;
    isLike: string;
    gt: string;
    lt: string;
    gte: string;
    lte: string;
};
type Clause<T extends Resource> = Record<keyof typeof operators, (value: ColumnValue) => Query<T>>;
type PropertiesOf<T extends Resource> = {
    [K in keyof T]: T[K] extends () => any ? never : K;
}[keyof T];
export type ResourceProperties<T extends Resource> = {
    [K in PropertiesOf<T>]: T[K] extends never ? never : T[K];
};
type Filter<T extends Resource> = [PropertiesOf<T>, string, ColumnValue];
export declare class Query<T extends Resource> {
    private readonly q;
    push(field: PropertiesOf<T>, operator: string, value: ColumnValue): this;
    where(field: PropertiesOf<T>): Clause<T>;
    toJSON(): Filter<T>[];
}
export interface ResourceDescription {
    name: string;
    fields: TableColumn[];
}
export declare class Resource {
    private static driver;
    static use(driver: ResourceDriver): void;
    static describe<T>(resourceOrModel: ConstructorOf<Resource> | T): ResourceDescription;
    static find<T extends Resource>(resource: ConstructorOf<T>, query: Query<T>): Promise<T[]>;
    static create(resource: typeof Resource): Promise<void>;
    constructor(props?: any);
    static getMetadataOf: typeof getMetadataOf;
    save(): Promise<string>;
    remove(): Promise<void>;
    find(): Promise<this>;
}
export declare abstract class ResourceDriver {
    abstract create(resource: typeof Resource): Promise<void>;
    abstract save<T extends Resource>(model: T): Promise<string>;
    abstract remove<T extends Resource>(model: T): Promise<void>;
    abstract find<T extends Resource>(model: T): Promise<T>;
    abstract findAll<M extends Resource>(resource: ConstructorOf<M>, query: Query<M>): Promise<M[]>;
}
export {};