@bitwild/rockets-auth/dist/__fixtures__/sqlite-adapter/sqlite-repository.adapter.d.ts

Rockets Auth - Complete authentication and authorization solution for NestJS with JWT, OAuth, OTP, role-based access control, and more

import * as sqlite3 from 'sqlite3';
import { PlainLiteralObject } from '@nestjs/common';
import { DeepPartial, RepositoryInternals, RepositoryInterface } from '@concepta/nestjs-common';
interface QueryOperator<T = unknown> {
    $gt?: T;
    $gte?: T;
    $lt?: T;
    $lte?: T;
}
interface DatabaseRow extends Record<string, unknown> {
}
interface SqliteRunResult {
    lastID: number;
    changes: number;
}
type DatabaseValue = string | number | boolean | Date | null | undefined;
interface ColumnMetadata {
    type: string;
    nullable?: boolean;
    unique?: boolean;
    default?: string | number | boolean;
    length?: number;
}
type WhereClause = Record<string, unknown | QueryOperator>;
type OrderClause = Record<string, 'ASC' | 'DESC'>;
interface ColumnOptions {
    type?: string;
    nullable?: boolean;
    unique?: boolean;
    default?: string | number | boolean;
    length?: number;
}
interface TableOptions {
    name?: string;
}
export declare function Column(options?: ColumnOptions): (target: Record<string, unknown>, propertyKey: string) => void;
export declare function Table(options?: TableOptions): (target: Record<string, unknown>) => void;
export declare class SqliteRepositoryAdapter<Entity extends PlainLiteralObject> implements RepositoryInterface<Entity> {
    protected db: sqlite3.Database;
    protected readonly tableName: string;
    protected readonly entityClass: new () => Entity;
    private columnCache;
    constructor(entityClass: new () => Entity, dbPath?: string);
    private getTableNameFromEntity;
    private analyzeEntityProperties;
    private inferColumnMetadata;
    private inferTypeFromPropertyName;
    private applyUniversalConstraints;
    private getEntityColumns;
    clearColumnCache(): void;
    getColumnMetadata(): Record<string, ColumnMetadata>;
    hasColumn(columnName: string): boolean;
    protected initializeTable(): void;
    protected ensureColumnsExist(requiredColumns: string[]): Promise<void>;
    protected mapRowToEntity(row: DatabaseRow): Entity;
    protected mapEntityToParams(entity: Entity): DatabaseValue[];
    protected getColumnNames(): string[];
    entityName(): string;
    protected generateId(): string;
    protected runQuery(sql: string, params?: DatabaseValue[]): Promise<SqliteRunResult>;
    protected getQuery(sql: string, params?: DatabaseValue[]): Promise<DatabaseRow | undefined>;
    protected allQuery(sql: string, params?: DatabaseValue[]): Promise<DatabaseRow[]>;
    protected buildWhereClause(where: WhereClause, params: DatabaseValue[]): string;
    protected buildOrderClause(order: OrderClause): string;
    find(options?: RepositoryInternals.FindManyOptions<Entity>): Promise<Entity[]>;
    findOne(options: RepositoryInternals.FindOneOptions<Entity>): Promise<Entity | null>;
    create(entityLike: DeepPartial<Entity>): Entity;
    merge(mergeIntoEntity: Entity, ...entityLikes: DeepPartial<Entity>[]): Entity;
    save<T extends DeepPartial<Entity>>(entities: T[], options?: RepositoryInternals.SaveOptions): Promise<(T & Entity)[]>;
    save<T extends DeepPartial<Entity>>(entity: T, options?: RepositoryInternals.SaveOptions): Promise<T & Entity>;
    remove(entities: Entity[]): Promise<Entity[]>;
    remove(entity: Entity): Promise<Entity>;
    gt<T>(value: T): QueryOperator<T>;
    gte<T>(value: T): QueryOperator<T>;
    lt<T>(value: T): QueryOperator<T>;
    lte<T>(value: T): QueryOperator<T>;
    close(): Promise<void>;
}
export {};
//# sourceMappingURL=sqlite-repository.adapter.d.ts.map