@vritti/api-sdk 0.3.3 → 0.3.6

package/dist/database.d.ts

@@ -0,0 +1,287 @@
+import { InjectionToken, DynamicModule, OnModuleInit, OnModuleDestroy, Logger } from '@nestjs/common';
+import { PoolClient } from 'pg';
+import { T as TableViewState, F as FilterOperator, a as FilterCondition, S as SearchState, b as SortCondition } from './filter.types-PuARU9XD.js';
+export { C as ColumnPinning, D as DensityType, c as FilterOperators } from './filter.types-PuARU9XD.js';
+import { Column, SQL, InferInsertModel, InferSelectModel, InferSelectViewModel } from 'drizzle-orm';
+import { PgTable, PgSequence, PgColumn } from 'drizzle-orm/pg-core';
+import { PgViewBase } from 'drizzle-orm/pg-core/view-base';
+import { NodePgDatabase } from 'drizzle-orm/node-postgres';
+
+interface PrimaryDbConfig {
+    host: string;
+    port?: number;
+    username: string;
+    password: string;
+    database: string;
+    schema?: string;
+    sslMode?: 'require' | 'prefer' | 'disable' | 'no-verify';
+}
+interface DatabaseModuleOptions {
+    primaryDb: PrimaryDbConfig;
+    drizzleRelations?: Record<string, any>;
+    maxConnections?: number;
+    applyRlsContext?: (client: PoolClient, ctx: unknown) => Promise<void>;
+}
+
+declare class DatabaseModule {
+    static forServer<T extends unknown[] = unknown[]>(options: {
+        useFactory: (...args: [...T]) => Promise<DatabaseModuleOptions> | DatabaseModuleOptions;
+        inject?: InjectionToken[];
+    }): DynamicModule;
+}
+
+declare class CreateResponseDto<T> {
+    success: boolean;
+    message: string;
+    data: T;
+}
+
+declare class CursorListResponseDto<T> {
+    items: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+
+declare class ValidatedRowDto {
+    index: number;
+    data: Record<string, string>;
+    valid: boolean;
+    errors: string[];
+}
+declare class ImportSummaryDto {
+    total: number;
+    valid: number;
+    invalid: number;
+}
+declare class ImportResponseDto {
+    success: boolean;
+    message: string;
+    created?: number;
+    updated?: number;
+    skipped?: number;
+    rows?: ValidatedRowDto[];
+    summary?: ImportSummaryDto;
+}
+
+declare class SelectOptionsQueryDto {
+    search?: string;
+    limit?: number;
+    offset?: number;
+    values?: string;
+    excludeIds?: string;
+    valueKey?: string;
+    labelKey?: string;
+    descriptionKey?: string;
+    additionalKeys?: string;
+    groupIdKey?: string;
+    orderByKey?: string;
+    orderDirection?: 'asc' | 'desc';
+}
+
+declare class SuccessResponseDto {
+    success: boolean;
+    message: string;
+}
+
+declare class TableResponseDto<T> {
+    result: T[];
+    count: number;
+    state: TableViewState;
+    activeViewId: string | null;
+}
+
+declare class CursorCodec {
+    static encode(values: unknown[], signature?: string): string;
+    static decode(cursor: string, expectedSignature?: string): unknown[];
+}
+
+type FieldDefinition = {
+    column: Column;
+    type: 'string' | 'number' | 'boolean';
+    nulls?: 'first' | 'last';
+} | {
+    expression: (value: string | number, operator: FilterOperator) => SQL;
+    type: 'string' | 'number' | 'boolean';
+};
+type FieldMap = Record<string, FieldDefinition>;
+declare class FilterProcessor {
+    static buildWhere(filters: FilterCondition[] | undefined, fieldMap: FieldMap): SQL | undefined;
+    static buildSearch(search: SearchState | null | undefined, fieldMap: FieldMap): SQL | undefined;
+    static buildOrderBy(sort: SortCondition[] | undefined, fieldMap: FieldMap): SQL[];
+}
+
+declare const MAX_PAGE_SIZE = 100;
+interface KeysetOrderBy {
+    column: Column;
+    direction: 'asc' | 'desc';
+    nulls?: 'first' | 'last';
+}
+declare function keysetSignature(entries: {
+    key: string;
+    direction: 'asc' | 'desc';
+}[]): string;
+declare class KeysetProcessor {
+    static buildAfter(orderBy: KeysetOrderBy[], values: unknown[]): SQL;
+    private static buildRowValue;
+    private static buildOrExpansion;
+    private static tie;
+    private static strictlyAfter;
+}
+
+type TypedDrizzleClient = NodePgDatabase;
+
+declare class PrimaryDatabaseService implements OnModuleInit, OnModuleDestroy {
+    private readonly options;
+    private readonly logger;
+    private pool;
+    private db;
+    private readonly rlsAls;
+    private readonly txAls;
+    constructor(options: DatabaseModuleOptions);
+    onModuleInit(): Promise<void>;
+    private initializeDrizzleClient;
+    get drizzleClient(): TypedDrizzleClient;
+    runWithRlsContext<T>(rls: unknown, fn: () => Promise<T>): Promise<T>;
+    runInTransaction<T>(fn: () => Promise<T>): Promise<T>;
+    runWithPinnedConnection<T>(fn: () => Promise<T>): Promise<T>;
+    onModuleDestroy(): Promise<void>;
+}
+
+interface SelectQueryOption {
+    value: string | number | boolean;
+    label: string;
+    description?: string;
+    additionals?: Record<string, string | number | boolean | null>;
+    groupId?: string | number;
+}
+interface SelectQueryGroup {
+    id: string | number;
+    name: string;
+}
+interface SelectQueryResult {
+    options: SelectQueryOption[];
+    groups?: SelectQueryGroup[];
+    hasMore: boolean;
+    totalCount?: number;
+}
+interface FindForSelectJoin {
+    table: PgTable;
+    on: SQL;
+    type?: 'left' | 'inner';
+}
+interface FindForSelectConfig {
+    value: string;
+    label: string;
+    description?: string;
+    additionalKeys?: string | string[];
+    additionalExpressions?: Record<string, SQL>;
+    groupIdKey?: string;
+    search?: string;
+    limit?: number;
+    offset?: number;
+    where?: Record<string, unknown>;
+    orderByKey?: string;
+    orderDirection?: 'asc' | 'desc';
+    orderBy?: Record<string, 'asc' | 'desc'>;
+    groups?: SelectQueryGroup[];
+    values?: string | (string | number | boolean)[];
+    excludeIds?: string | (string | number | boolean)[];
+    groupTable?: PgTable;
+    groupLabelKey?: string;
+    groupTableIdKey?: string;
+    joins?: FindForSelectJoin[];
+    conditions?: SQL[];
+    distinct?: boolean;
+}
+
+type RelationsWhereFilter = Record<string, unknown>;
+interface TypedRelationalQueryBuilder<TSelect> {
+    findFirst(config?: {
+        where?: RelationsWhereFilter;
+        with?: Record<string, unknown>;
+        columns?: Record<string, boolean>;
+    }): Promise<TSelect | undefined>;
+    findMany(config?: {
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
+        limit?: number;
+        offset?: number;
+        with?: Record<string, unknown>;
+        columns?: Record<string, boolean>;
+    }): Promise<TSelect[]>;
+}
+declare abstract class PrimaryBaseRepository<TTable extends PgTable | PgViewBase, TInsert = TTable extends PgTable ? InferInsertModel<TTable> : never, TSelect = TTable extends PgTable ? InferSelectModel<TTable> : TTable extends PgViewBase ? InferSelectViewModel<TTable> : never> {
+    protected readonly database: PrimaryDatabaseService;
+    protected readonly table: TTable;
+    protected readonly logger: Logger;
+    protected readonly sequence?: PgSequence;
+    private readonly tableName;
+    private readonly isView;
+    protected get db(): TypedDrizzleClient;
+    protected get model(): TypedRelationalQueryBuilder<TSelect>;
+    constructor(database: PrimaryDatabaseService, table: TTable, options?: {
+        sequence?: PgSequence;
+    });
+    protected nextSequenceValue(sequence?: PgSequence): Promise<number>;
+    create(data: TInsert, tx?: TypedDrizzleClient): Promise<TSelect>;
+    findById(id: string): Promise<TSelect | undefined>;
+    findOne(where: RelationsWhereFilter): Promise<TSelect | undefined>;
+    findMany(options?: {
+        where?: RelationsWhereFilter;
+        orderBy?: Record<string, 'asc' | 'desc'>;
+        limit?: number;
+        offset?: number;
+    }): Promise<TSelect[]>;
+    private buildSelectQuery;
+    findAllAndCount<TResult = TSelect>(options?: {
+        select?: Record<string, unknown>;
+        where?: SQL;
+        orderBy?: SQL[];
+        limit?: number;
+        offset?: number;
+        leftJoin?: {
+            table: PgTable;
+            on: SQL | undefined;
+        };
+        leftJoins?: {
+            table: PgTable;
+            on: SQL | undefined;
+        }[];
+        groupBy?: (PgColumn | SQL)[];
+    }): Promise<{
+        result: TResult[];
+        count: number;
+    }>;
+    findKeyset<TResult = TSelect>(options: {
+        select?: Record<string, unknown>;
+        where?: SQL;
+        orderBy: SQL[];
+        limit: number;
+        leftJoin?: {
+            table: PgTable;
+            on: SQL | undefined;
+        };
+        leftJoins?: {
+            table: PgTable;
+            on: SQL | undefined;
+        }[];
+        groupBy?: (PgColumn | SQL)[];
+    }): Promise<{
+        rows: TResult[];
+        hasMore: boolean;
+    }>;
+    update(id: string, data: Partial<TInsert>, tx?: TypedDrizzleClient): Promise<TSelect>;
+    updateMany(where: SQL, data: Partial<TInsert>, tx?: TypedDrizzleClient): Promise<{
+        count: number;
+    }>;
+    delete(id: string, tx?: TypedDrizzleClient): Promise<TSelect>;
+    deleteMany(where: SQL, tx?: TypedDrizzleClient): Promise<{
+        count: number;
+    }>;
+    count(where?: SQL): Promise<number>;
+    exists(where: SQL): Promise<boolean>;
+    transaction<T>(callback: (tx: TypedDrizzleClient) => Promise<T>): Promise<T>;
+    findForSelect(config: FindForSelectConfig): Promise<SelectQueryResult>;
+}
+
+export { CreateResponseDto, CursorCodec, CursorListResponseDto, DatabaseModule, type DatabaseModuleOptions, type FieldDefinition, type FieldMap, FilterCondition, FilterOperator, FilterProcessor, type FindForSelectConfig, type FindForSelectJoin, ImportResponseDto, ImportSummaryDto, type KeysetOrderBy, KeysetProcessor, MAX_PAGE_SIZE, PrimaryBaseRepository, PrimaryDatabaseService, type PrimaryDbConfig, SearchState, SelectOptionsQueryDto, type SelectQueryGroup, type SelectQueryOption, type SelectQueryResult, SortCondition, SuccessResponseDto, TableResponseDto, TableViewState, type TypedDrizzleClient, ValidatedRowDto, keysetSignature };