@cleverbrush/knex-schema 4.0.0 → 4.2.0

package/dist/operations/delete.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+export declare function deleteImpl(builder: SchemaQueryBuilder<any, any>): Promise<number>;
+export declare function withDeletedImpl(builder: SchemaQueryBuilder<any, any>): any;
+export declare function onlyDeletedImpl(builder: SchemaQueryBuilder<any, any>): any;
+export declare function hardDeleteImpl(builder: SchemaQueryBuilder<any, any>): Promise<number>;
+export declare function restoreImpl(builder: SchemaQueryBuilder<any, any>): Promise<any[]>;

package/dist/operations/helpers.d.ts

@@ -0,0 +1,57 @@
+import type { InferType } from '@cleverbrush/schema';
+import { EXTRA_TYPE_BRAND, METHOD_LITERAL_BRAND, ObjectSchemaBuilder } from '@cleverbrush/schema';
+import type { Knex } from 'knex';
+import { POLYMORPHIC_TYPE_BRAND } from '../extension.js';
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { ResolvedVariantConfig, ValidatedSpec } from '../types.js';
+export type ScopesOf<S> = S extends {
+    readonly [METHOD_LITERAL_BRAND]?: infer N;
+} ? Extract<N, string> : never;
+export type ProjectionsOf<S> = S extends {
+    readonly [EXTRA_TYPE_BRAND]?: infer P;
+} ? P extends Record<string, readonly string[]> ? P : Record<never, never> : Record<never, never>;
+export type ProjectionKeysOf<S, K extends keyof ProjectionsOf<S> & string> = ProjectionsOf<S>[K] extends readonly (infer T extends string)[] ? T : string;
+export type QueryResultType<TLocalSchema> = TLocalSchema extends {
+    readonly [POLYMORPHIC_TYPE_BRAND]?: infer U;
+} ? NonNullable<U> : InferType<TLocalSchema>;
+export declare function resolveColumn(builder: SchemaQueryBuilder<any, any>, ref: any, label?: string): string | Knex.Raw;
+export declare function invalidateCache(builder: SchemaQueryBuilder<any, any>): void;
+export declare function getSoftDelete(builder: SchemaQueryBuilder<any, any>): {
+    column: string;
+} | null;
+export declare function getDefaultScope(builder: SchemaQueryBuilder<any, any>): Function | null;
+export declare function getTimestamps(builder: SchemaQueryBuilder<any, any>): {
+    createdAt: string;
+    updatedAt: string;
+} | null;
+declare const ALLOWED_OPS: Set<string>;
+export { ALLOWED_OPS };
+export declare function getVariantConfig(builder: SchemaQueryBuilder<any, any>): ResolvedVariantConfig | null;
+export declare function applyVariantJoins(builder: SchemaQueryBuilder<any, any>, base: Knex.QueryBuilder, variantConfig: ResolvedVariantConfig): Knex.QueryBuilder;
+export declare function registerSchemaQueryBuilder(ctor: new (...args: any[]) => any): void;
+export declare function getSchemaQueryBuilderCtor(): new (...args: any[]) => any;
+export declare function buildVariantRelationSelect(builder: SchemaQueryBuilder<any, any>, foreignSchema: ObjectSchemaBuilder<any, any, any, any, any, any, any>, relAlias: string, foreignTableName: string, customize?: (q: SchemaQueryBuilder<any, any>) => void): Knex.Raw[];
+export declare function mapPolymorphicRow(builder: SchemaQueryBuilder<any, any>, row: Record<string, any>, variantConfig: ResolvedVariantConfig): Record<string, any>;
+export declare function resolveSchema(_builder: SchemaQueryBuilder<any, any>, schema: any): ObjectSchemaBuilder<any, any, any, any, any, any, any>;
+export declare function findPrimaryKeyColumn(_builder: SchemaQueryBuilder<any, any>, schema: ObjectSchemaBuilder<any, any, any, any, any, any, any>): string;
+export declare function resolvePkColumns(builder: SchemaQueryBuilder<any, any>): {
+    propertyKeys: readonly string[];
+    columnNames: readonly string[];
+};
+export declare function getEffectiveBaseQuery(builder: SchemaQueryBuilder<any, any>): Knex.QueryBuilder;
+export declare function buildJoinOne(builder: SchemaQueryBuilder<any, any>, resultQuery: Knex.QueryBuilder, spec: ValidatedSpec & {
+    type: 'one';
+}, relationAlias: string): void;
+export declare function buildJoinMany(builder: SchemaQueryBuilder<any, any>, resultQuery: Knex.QueryBuilder, spec: ValidatedSpec & {
+    type: 'many';
+}, relationAlias: string, i: number): void;
+export declare function buildQuery(builder: SchemaQueryBuilder<any, any>): Knex.QueryBuilder;
+export declare function getQuery(builder: SchemaQueryBuilder<any, any>): Knex.QueryBuilder;
+export declare function mapRow(builder: SchemaQueryBuilder<any, any>, row: Record<string, any>): Record<string, any>;
+export declare function cleanAndMapRow(builder: SchemaQueryBuilder<any, any>, row: Record<string, any>): Record<string, any>;
+export declare function mapObjectToColumns(builder: SchemaQueryBuilder<any, any>, obj: Record<string, any>): Record<string, any>;
+export declare function mapRecordToColumns(builder: SchemaQueryBuilder<any, any>, record: Record<string, any>): Record<string, any>;
+export declare function resolveColumnArg(builder: SchemaQueryBuilder<any, any>, col: any): string | Knex.Raw;
+export declare function isColumnAccessor(builder: SchemaQueryBuilder<any, any>, fn: Function): boolean;
+export declare function assertNotProjection(builder: SchemaQueryBuilder<any, any>, method: string): void;
+export declare function assertNotExplicitSelect(builder: SchemaQueryBuilder<any, any>, method: string): void;

package/dist/operations/insert.d.ts

@@ -0,0 +1,26 @@
+import type { InferType } from '@cleverbrush/schema';
+import type { Knex } from 'knex';
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { ColumnRef, InsertType } from '../types.js';
+export declare class OnConflictBuilder<TLocalSchema extends import('@cleverbrush/schema').ObjectSchemaBuilder<any, any, any, any, any, any, any>, TResult> {
+    #private;
+    constructor(knex: Knex, localSchema: TLocalSchema, _parent: SchemaQueryBuilder<TLocalSchema, TResult>, conflictColumns: string[]);
+    merge(data: InsertType<TLocalSchema>, updateData?: Partial<InferType<TLocalSchema>>): Promise<TResult>;
+    ignore(data: InsertType<TLocalSchema>): Promise<TResult | undefined>;
+}
+export declare function insertImpl(builder: SchemaQueryBuilder<any, any>, data: InsertType<any>): Promise<any>;
+export declare function insertManyImpl(builder: SchemaQueryBuilder<any, any>, data: InsertType<any>[]): Promise<any[]>;
+export declare function onConflictImpl(builder: SchemaQueryBuilder<any, any>, ...conflictColumns: ColumnRef<any>[]): OnConflictBuilder<any, any>;
+export declare function upsertImpl(builder: SchemaQueryBuilder<any, any>, data: InsertType<any>, opts: {
+    conflictColumns: ColumnRef<any>[];
+    updateColumns?: ColumnRef<any>[];
+}): Promise<any>;
+export declare function bulkInsertImpl(builder: SchemaQueryBuilder<any, any>, rows: InsertType<any>[], opts?: {
+    chunkSize?: number;
+    onConflict?: 'ignore' | 'merge';
+    conflictColumns?: ColumnRef<any>[];
+}): Promise<any[]>;
+export declare function bulkUpsertImpl(builder: SchemaQueryBuilder<any, any>, rows: InsertType<any>[], opts: {
+    conflictColumns: ColumnRef<any>[];
+    chunkSize?: number;
+}): Promise<any[]>;

package/dist/operations/join.d.ts

@@ -0,0 +1,6 @@
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { JoinManySpec, JoinOneSpec } from '../types.js';
+export declare function joinOneImpl(builder: SchemaQueryBuilder<any, any>, spec: JoinOneSpec<any, any, any, any>): any;
+export declare function joinManyImpl(builder: SchemaQueryBuilder<any, any>, spec: JoinManySpec<any, any, any>): any;
+export declare function includeImpl(builder: SchemaQueryBuilder<any, any>, relationName: string, customize?: (q: SchemaQueryBuilder<any, any>) => void): any;
+export declare function includeVariantImpl(builder: SchemaQueryBuilder<any, any>, variantKey: string, relationName: string, customize?: (q: SchemaQueryBuilder<any, any>) => void): any;

package/dist/operations/pagination.d.ts

@@ -0,0 +1,15 @@
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { ColumnRef, CursorPaginationResult, PaginationResult } from '../types.js';
+export declare function limitImpl(builder: SchemaQueryBuilder<any, any>, n: number): any;
+export declare function offsetImpl(builder: SchemaQueryBuilder<any, any>, n: number): any;
+export declare function paginateImpl(builder: SchemaQueryBuilder<any, any>, opts: {
+    page: number;
+    pageSize: number;
+}): Promise<PaginationResult<any>>;
+export declare function paginateAfterImpl(builder: SchemaQueryBuilder<any, any>, opts: {
+    cursor?: any;
+    limit: number;
+    column?: ColumnRef<any>;
+    direction?: 'asc' | 'desc';
+}): Promise<CursorPaginationResult<any>>;
+export declare function executeImpl(builder: SchemaQueryBuilder<any, any>): Promise<any[]>;

package/dist/operations/select.d.ts

@@ -0,0 +1,15 @@
+import type { Knex } from 'knex';
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { ColumnRef } from '../types.js';
+export declare function selectImpl(builder: SchemaQueryBuilder<any, any>, ...args: unknown[]): any;
+export declare function distinctImpl(builder: SchemaQueryBuilder<any, any>, ...columns: (ColumnRef<any> | Knex.Raw)[]): any;
+export declare function countImpl(builder: SchemaQueryBuilder<any, any>, column?: ColumnRef<any> | Knex.Raw): any;
+export declare function countDistinctImpl(builder: SchemaQueryBuilder<any, any>, column?: ColumnRef<any> | Knex.Raw): any;
+export declare function minImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any> | Knex.Raw): any;
+export declare function maxImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any> | Knex.Raw): any;
+export declare function sumImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any> | Knex.Raw): any;
+export declare function avgImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any> | Knex.Raw): any;
+export declare function selectRawImpl(builder: SchemaQueryBuilder<any, any>, sql: string, bindings?: any[]): any;
+export declare function projectedImpl(builder: SchemaQueryBuilder<any, any>, name: string): any;
+export declare function scopedImpl(builder: SchemaQueryBuilder<any, any>, name: string): any;
+export declare function unscopedImpl(builder: SchemaQueryBuilder<any, any>): any;

package/dist/operations/state.d.ts

@@ -0,0 +1,39 @@
+import type { ObjectSchemaBuilder } from '@cleverbrush/schema';
+import type { Knex } from 'knex';
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { ResolvedVariantConfig, ValidatedSpec, VariantWhereFilter } from '../types.js';
+export interface QueryBuilderState {
+    knex: Knex;
+    baseQuery: Knex.QueryBuilder;
+    localSchema: ObjectSchemaBuilder<any, any, any, any, any, any, any>;
+    specs: ValidatedSpec[];
+    tableName: string;
+    /** SQL column names explicitly passed to `.select()`. null = SELECT *. */
+    explicitSelects: string[] | null;
+    /** Column-selection mode: null, 'select', 'aggregate', or 'projection'. */
+    selectionMode: 'select' | 'aggregate' | 'projection' | null;
+    /** Name of the projection currently applied, for error messages. */
+    appliedProjection: string | null;
+    /** When true, soft-delete filter is NOT applied. */
+    includeDeleted: boolean;
+    /** When true, only soft-deleted rows are returned. */
+    onlyDeleted: boolean;
+    /** When true, default scope is not applied. */
+    skipDefaultScope: boolean;
+    /** Resolved variant config, lazily populated. undefined = not yet read; null = not polymorphic. */
+    variantConfig: ResolvedVariantConfig | null | undefined;
+    /** When set, only these discriminator values are returned. null = all variants. */
+    enabledVariants: Set<string> | null;
+    /** Pending per-variant WHERE filters registered via .whereVariant(). */
+    variantWhereFilters: VariantWhereFilter[];
+    /** Variant-relation eager-load requests registered via .includeVariant(). */
+    variantRelationIncludes: Array<{
+        variantKey: string;
+        relationName: string;
+        customize?: (q: SchemaQueryBuilder<any, any>) => void;
+    }>;
+    /** Memoized result of buildQuery(). null = needs rebuild. */
+    cachedBuiltQuery: Knex.QueryBuilder | null;
+}
+export declare function getState(builder: SchemaQueryBuilder<any, any>): QueryBuilderState;
+export declare function setState(builder: SchemaQueryBuilder<any, any>, state: QueryBuilderState): void;

package/dist/operations/update.d.ts

@@ -0,0 +1,7 @@
+import type { InferType } from '@cleverbrush/schema';
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+export declare function updateImpl(builder: SchemaQueryBuilder<any, any>, data: Partial<InferType<any>>): Promise<any[]>;
+export declare function bulkUpdateImpl(builder: SchemaQueryBuilder<any, any>, updates: ReadonlyArray<{
+    where: Partial<InferType<any>>;
+    set: Partial<InferType<any>>;
+}>): Promise<number>;

package/dist/operations/where.d.ts

@@ -0,0 +1,29 @@
+import type { Knex } from 'knex';
+import type { SchemaQueryBuilder } from '../SchemaQueryBuilder.js';
+import type { ColumnRef } from '../types.js';
+export declare function whereImpl(builder: SchemaQueryBuilder<any, any>, columnOrRaw: any, ...args: any[]): any;
+export declare function andWhereImpl(builder: SchemaQueryBuilder<any, any>, columnOrRaw: any, ...args: any[]): any;
+export declare function orWhereImpl(builder: SchemaQueryBuilder<any, any>, columnOrRaw: any, ...args: any[]): any;
+export declare function whereNotImpl(builder: SchemaQueryBuilder<any, any>, columnOrRaw: any, ...args: any[]): any;
+export declare function whereInImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, values: readonly any[] | Knex.QueryBuilder): any;
+export declare function whereNotInImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, values: readonly any[] | Knex.QueryBuilder): any;
+export declare function orWhereInImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, values: readonly any[] | Knex.QueryBuilder): any;
+export declare function orWhereNotInImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, values: readonly any[] | Knex.QueryBuilder): any;
+export declare function whereNullImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>): any;
+export declare function whereNotNullImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>): any;
+export declare function orWhereNullImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>): any;
+export declare function orWhereNotNullImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>): any;
+export declare function whereBetweenImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, range: readonly [any, any]): any;
+export declare function whereNotBetweenImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, range: readonly [any, any]): any;
+export declare function whereLikeImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, value: string): any;
+export declare function whereILikeImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, value: string): any;
+export declare function whereRawImpl(builder: SchemaQueryBuilder<any, any>, sql: string, ...bindings: any[]): any;
+export declare function whereExistsImpl(builder: SchemaQueryBuilder<any, any>, callback: Knex.QueryCallback | Knex.QueryBuilder): any;
+export declare function whereNotExistsImpl(builder: SchemaQueryBuilder<any, any>, callback: Knex.QueryCallback | Knex.QueryBuilder): any;
+export declare function whereJsonPathImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any>, path: string, operator?: string, value?: any): any;
+export declare function orderByImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any> | Knex.Raw, direction?: 'asc' | 'desc'): any;
+export declare function orderByRawImpl(builder: SchemaQueryBuilder<any, any>, sql: string, ...bindings: any[]): any;
+export declare function groupByImpl(builder: SchemaQueryBuilder<any, any>, ...columns: (ColumnRef<any> | Knex.Raw)[]): any;
+export declare function groupByRawImpl(builder: SchemaQueryBuilder<any, any>, sql: string, ...bindings: any[]): any;
+export declare function havingImpl(builder: SchemaQueryBuilder<any, any>, column: ColumnRef<any> | Knex.Raw, operator: string, value: any): any;
+export declare function havingRawImpl(builder: SchemaQueryBuilder<any, any>, sql: string, ...bindings: any[]): any;

package/package.json

@@ -5,7 +5,7 @@
         "email": "andrew_zol@cleverbrush.com"
     },
     "dependencies": {
-        "@cleverbrush/schema": "^4.0.0"
+        "@cleverbrush/schema": "^4.2.0"
     },
     "peerDependencies": {
         "knex": ">=3.1.0"
@@ -52,5 +52,5 @@
     },
     "type": "module",
     "types": "./dist/index.d.ts",
-    "version": "4.0.0"
+    "version": "4.2.0"
 }