@kava/kava-api-core 1.0.0

package/dist/model.util.d.ts

@@ -0,0 +1,204 @@
+import type { Knex } from 'knex';
+export declare const PRIMARY_KEY_META: unique symbol;
+export declare const FIELD_META: unique symbol;
+export declare const RELATION_META: unique symbol;
+export declare const SOFT_DELETE_META: unique symbol;
+export declare const ATTRIBUTE_META: unique symbol;
+export declare const FORMATTER_META: unique symbol;
+export declare const SCOPE_META: unique symbol;
+export type FieldFlag = 'fillable' | 'selectable' | 'searchable' | 'hidden';
+export type FieldMeta = {
+    cast?: ModelCastType;
+    fillable?: boolean;
+    selectable?: boolean;
+    searchable?: boolean;
+    hidden?: boolean;
+};
+type NonFunctionKeys<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+type DataShape<T> = Pick<T, NonFunctionKeys<T>>;
+type ModelPayload<T> = Partial<DataShape<T>>;
+export type ModelCastType = 'string' | 'number' | 'boolean' | 'date' | 'json';
+export type ModelRelationType = 'hasMany' | 'hasOne' | 'belongsTo' | 'belongsToMany';
+export type ModelRelationDescriptor = {
+    type: ModelRelationType;
+    model: () => typeof Model;
+    foreignKey: string;
+    localKey: string;
+    pivotTable?: string;
+    pivotLocal?: string;
+    pivotForeign?: string;
+    callback?: (q: any) => void;
+};
+export type ModelHookEventType = "before-create" | "after-create" | "before-update" | "after-update" | "before-delete" | "after-delete";
+export type ModelHookFn = (ctx: ModelHookContextType) => any;
+export type ModelHookContextType<T extends Model = Model> = {
+    model: T;
+    trx?: any;
+    snapshot?: any;
+};
+export type ScopeType = {
+    fn: Function;
+    mode: 'global' | 'internal';
+};
+declare module 'knex' {
+    namespace Knex {
+        interface QueryBuilder<TRecord = any, TResult = any> {
+            $model?: any;
+            _withTree?: Record<string, any>;
+            _formatter?: ((item: any) => any) | null;
+            _softDeleteScope?: 'default' | 'with' | 'only';
+            _withAggregates?: Array<{
+                relation: string;
+                alias: string;
+                fn: 'count' | 'sum' | 'avg' | 'min' | 'max';
+                column: string;
+                callback?: (q: any) => void;
+            }>;
+            _orderByAggregates?: Array<{
+                relation: string;
+                alias?: string;
+                fn: 'count' | 'sum' | 'avg' | 'min' | 'max';
+                column: string;
+                direction: 'asc' | 'desc';
+                callback?: (q: any) => void;
+            }>;
+        }
+    }
+}
+export interface ModelQueryBuilder<T extends Record<string, any> = Record<string, any>> extends Knex.QueryBuilder<T, T[]> {
+    _withTree?: Record<string, any>;
+    _formatter?: ((item: T) => any) | null;
+    _softDeleteScope?: 'default' | 'with' | 'only';
+    findOrNotFound(id: string | number): Promise<T>;
+    firstOrNotFound(): Promise<T>;
+    search(keyword?: string, options?: {
+        includes?: string[];
+        searchable?: string[];
+    }): this;
+    filter(filters?: Record<string, string>): this;
+    selects(options?: {
+        includes?: string[];
+        selectable?: string[];
+    }): this;
+    sorts(sorts?: string[]): this;
+    with(relation: string, callback?: any): this;
+    expand(relations?: Array<string | Record<string, (q: any) => void>>): this;
+    whereHas(relation: string, callback?: (q: ModelQueryBuilder<any>) => void): this;
+    orWhereHas(relation: string, callback?: (q: ModelQueryBuilder<any>) => void): this;
+    whereDoesntHave(relation: string, callback?: (q: ModelQueryBuilder<any>) => void): this;
+    orWhereDoesntHave(relation: string, callback?: (q: ModelQueryBuilder<any>) => void): this;
+    withAggregate(expr: string, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column?: string, callback?: (q: ModelQueryBuilder<any>) => void): this;
+    orderByAggregate(expr: string, fn: 'count' | 'sum' | 'avg' | 'min' | 'max', column?: string, direction?: 'asc' | 'desc', callback?: (q: ModelQueryBuilder<any>) => void): this;
+    get(): Promise<T[]>;
+    getFirst(): Promise<T>;
+    paginate(page?: number, limit?: number): Promise<{
+        data: T[];
+        total: number;
+    }>;
+    option(selectableOption?: string[]): Promise<Array<{
+        value: any;
+        label: any;
+    }>>;
+    paginateOrOption(page?: number, limit?: number, option?: string | boolean, selectableOption?: string[]): Promise<{
+        data: any[];
+        total: number;
+    }>;
+    resolve(input?: any): Promise<{
+        data: T[];
+        total: number;
+    }>;
+    format(formatter: string | ((item: T) => any)): this;
+    withTrashed(): this;
+    onlyTrashed(): this;
+}
+export declare abstract class Model {
+    id: number;
+    created_at: Date;
+    updated_at: Date;
+    deleted_at: Date;
+    static table: string;
+    static primaryKey: string;
+    static softDelete: boolean;
+    static deletedAtColumn: string;
+    protected _original: Record<string, any>;
+    protected _exists: boolean;
+    protected _trx?: Knex.Transaction;
+    private static _hooks;
+    private _instanceHooks;
+    private _disabledHooks;
+    constructor(data?: Record<string, any>);
+    protected static newInstance<T extends typeof Model>(this: T): InstanceType<T> & Model;
+    static [FIELD_META]?: Record<string, any>;
+    static getDefaultFields(): Record<string, FieldMeta>;
+    static get fields(): Record<string, FieldMeta>;
+    static get fillable(): string[];
+    static get selectable(): string[];
+    static get searchable(): string[];
+    static getTable(): string;
+    static getPrimaryKey(): string;
+    static [RELATION_META]?: Record<string, any>;
+    static get relations(): Record<string, any>;
+    static get attributes(): Record<string, Function>;
+    static get formatters(): Record<string, Function>;
+    static get scopes(): Record<string, ScopeType>;
+    getOriginal(key?: string): any;
+    getChanges(): Record<string, any>;
+    getPrevious(): Record<string, any>;
+    static query<T extends Record<string, any> = Record<string, any>>(trx?: Knex | Knex.Transaction): ModelQueryBuilder<T>;
+    castFromDB(row: Record<string, any>): this;
+    castToDB(): Record<string, any>;
+    getDirty(): Record<string, any>;
+    static hydrate<T extends typeof Model>(this: T, rows: any[] | null | undefined): InstanceType<T>[];
+    fill<T extends this>(this: T, payload: ModelPayload<T>): T;
+    static create<T extends typeof Model>(this: T, payload: ModelPayload<InstanceType<T>>, trx?: Knex.Transaction): Promise<InstanceType<T>>;
+    static update<T extends typeof Model>(this: T, payload: ModelPayload<InstanceType<T>>, uniqueKeys: (keyof InstanceType<T> & string)[], trx?: Knex.Transaction): Promise<InstanceType<T>>;
+    static upsert<T extends typeof Model>(this: T, payload: ModelPayload<InstanceType<T>>, uniqueKeys: (keyof InstanceType<T> & string)[], trx?: Knex.Transaction): Promise<InstanceType<T>>;
+    save(): Promise<this>;
+    pump<T extends this>(this: T, payload: ModelPayload<T> | ModelPayload<T>[], options?: {
+        trx?: Knex.Transaction;
+    }): Promise<T | T[]>;
+    static getSoftDeleteConfig(): any;
+    static isSoftDelete(): boolean;
+    static getDeletedAtColumn(): string | null;
+    delete(): Promise<Record<string, any> | null>;
+    forceDelete(): Promise<any>;
+    restore(): Promise<this>;
+    on<T extends this>(event: ModelHookEventType, fn: (ctx: ModelHookContextType<T>) => any): this;
+    off(event: ModelHookEventType): this;
+    protected runHook(event: ModelHookEventType, ctx: ModelHookContextType): Promise<void>;
+    toJSON(): Record<string, any>;
+    useTransaction(trx: Knex.Transaction): this;
+}
+export declare function extendModelQuery(query: Knex.QueryBuilder, Model: any): Knex.QueryBuilder<any, any>;
+export declare function PrimaryKey(): (target: any, key: string) => void;
+export declare function Field(defs: string[]): (target: any, key: string) => void;
+export declare function HasMany(model: () => typeof Model, options?: {
+    foreignKey?: string;
+    localKey?: string;
+    callback?: (q: any) => void;
+}): (target: any, key: string) => void;
+export declare function HasOne(model: () => typeof Model, options?: {
+    foreignKey?: string;
+    localKey?: string;
+    callback?: (q: any) => void;
+}): (target: any, key: string) => void;
+export declare function BelongsTo(model: () => typeof Model, options?: {
+    foreignKey?: string;
+    ownerKey?: string;
+    callback?: (q: any) => void;
+}): (target: any, key: string) => void;
+export declare function BelongsToMany(model: () => typeof Model, options?: {
+    pivotTable?: string;
+    pivotLocal?: string;
+    pivotForeign?: string;
+    localKey?: string;
+    callback?: (q: any) => void;
+}): (target: any, key: string) => void;
+export declare function SoftDelete(): (target: any, propertyKey: string) => void;
+export declare function Attribute(): (target: any, key: string, descriptor: PropertyDescriptor) => void;
+export declare function Formatter(): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function Scope(mode?: 'global' | 'internal'): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function On(event: ModelHookEventType): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export {};