@zudojs/database 0.0.1 → 1.0.0

package/dist/pagination/pagination.core.d.ts

@@ -0,0 +1,163 @@
+import type { PaginationInput, PaginationMeta, PaginatedResult } from "../databaseType/databaseType.type.js";
+/**
+ * Default pagination values.
+ */
+export declare const DEFAULT_PAGE = 1;
+export declare const DEFAULT_LIMIT = 20;
+export declare const MAX_LIMIT = 100;
+/**
+ * Normalized pagination configuration.
+ */
+export interface NormalizedPagination {
+    readonly page: number;
+    readonly limit: number;
+    readonly offset: number;
+}
+/**
+ * Cursor pagination request.
+ */
+export interface CursorPaginationInput {
+    readonly cursor?: string | null;
+    readonly limit?: number;
+}
+/**
+ * Cursor pagination metadata.
+ */
+export interface CursorPaginationMeta {
+    readonly limit: number;
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage: boolean;
+    readonly nextCursor?: string;
+    readonly previousCursor?: string;
+}
+/**
+ * Cursor paginated result.
+ */
+export interface CursorPaginatedResult<TEntity> {
+    readonly data: readonly TEntity[];
+    readonly meta: CursorPaginationMeta;
+}
+/**
+ * Normalizes page and limit values.
+ */
+export declare function normalizePagination(input?: PaginationInput): NormalizedPagination;
+/**
+ * Normalizes a page number.
+ */
+export declare function normalizePage(page?: number): number;
+/**
+ * Normalizes a page size.
+ */
+export declare function normalizeLimit(limit?: number): number;
+/**
+ * Calculates the database offset for a page.
+ */
+export declare function calculateOffset(page: number, limit: number): number;
+/**
+ * Calculates the total number of pages.
+ */
+export declare function calculateTotalPages(total: number, limit: number): number;
+/**
+ * Creates pagination metadata.
+ */
+export declare function createPaginationMeta(page: number, limit: number, total: number): PaginationMeta;
+/**
+ * Creates a paginated result.
+ */
+export declare function createPaginatedResult<TEntity>(data: readonly TEntity[], page: number, limit: number, total: number): PaginatedResult<TEntity>;
+/**
+ * Gets the next page number.
+ */
+export declare function getNextPage(meta: PaginationMeta): number | null;
+/**
+ * Gets the previous page number.
+ */
+export declare function getPreviousPage(meta: PaginationMeta): number | null;
+/**
+ * Checks whether a page number is valid for the result set.
+ */
+export declare function isValidPage(page: number, totalPages: number): boolean;
+/**
+ * Calculates the item range represented by a page.
+ *
+ * For example, page 2 with a limit of 20 and total of 55 returns
+ * `{ start: 21, end: 40 }`.
+ */
+export declare function getItemRange(page: number, limit: number, total: number): {
+    readonly start: number;
+    readonly end: number;
+};
+/**
+ * Applies offset pagination to an in-memory collection.
+ *
+ * This is useful for adapters and tests that need the same pagination
+ * semantics without querying the database directly.
+ */
+export declare function paginateCollection<TEntity>(items: readonly TEntity[], input?: PaginationInput): PaginatedResult<TEntity>;
+/**
+ * Normalizes cursor pagination input.
+ */
+export declare function normalizeCursorPagination(input?: CursorPaginationInput): Required<Pick<CursorPaginationInput, "limit">> & Pick<CursorPaginationInput, "cursor">;
+/**
+ * Creates cursor pagination metadata.
+ */
+export declare function createCursorPaginationMeta(limit: number, options: {
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage?: boolean;
+    readonly nextCursor?: string | null;
+    readonly previousCursor?: string | null;
+}): CursorPaginationMeta;
+/**
+ * Creates a cursor paginated result.
+ */
+export declare function createCursorPaginatedResult<TEntity>(data: readonly TEntity[], limit: number, options: {
+    readonly hasNextPage: boolean;
+    readonly hasPreviousPage?: boolean;
+    readonly nextCursor?: string | null;
+    readonly previousCursor?: string | null;
+}): CursorPaginatedResult<TEntity>;
+/**
+ * Options for encoding a cursor.
+ */
+export interface EncodeCursorOptions {
+    /**
+     * When supplied the cursor is signed with HMAC-SHA256 so clients cannot
+     * forge or tamper with its payload.
+     */
+    readonly secret?: string;
+}
+/**
+ * Options for decoding a cursor.
+ */
+export interface DecodeCursorOptions extends EncodeCursorOptions {
+    /**
+     * Keys the decoded payload may contain. Any other key is rejected.
+     */
+    readonly allowedFields?: readonly string[];
+}
+/**
+ * A validated cursor payload: a flat object of primitive values.
+ */
+export type CursorPayload = Readonly<Record<string, string | number | boolean | null>>;
+/**
+ * Encodes a cursor value.
+ *
+ * Without a `secret` the cursor is plain base64url JSON and must be treated
+ * as client-controlled input; pass `allowedFields` to `decodeCursor` (or
+ * use a secret) before feeding it to a query.
+ */
+export declare function encodeCursor(value: unknown, options?: EncodeCursorOptions): string;
+/**
+ * Decodes a cursor value.
+ *
+ * When `secret` is supplied the signature is verified; when
+ * `allowedFields` is supplied the payload must be a flat object whose keys
+ * are all allowed and whose values are primitives.
+ */
+export declare function decodeCursor<T = unknown>(cursor: string, options?: DecodeCursorOptions): T;
+/**
+ * Validates that a decoded cursor is a flat object of primitive values
+ * restricted to the allowed fields.
+ */
+export declare function validateCursorPayload(value: unknown, allowedFields: readonly string[]): asserts value is CursorPayload;
+//# sourceMappingURL=pagination.core.d.ts.map

package/dist/pagination/pagination.core.js

@@ -0,0 +1,279 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+/**
+ * Default pagination values.
+ */
+export const DEFAULT_PAGE = 1;
+export const DEFAULT_LIMIT = 20;
+export const MAX_LIMIT = 100;
+/**
+ * Normalizes page and limit values.
+ */
+export function normalizePagination(input) {
+    const page = normalizePage(input?.page);
+    const limit = normalizeLimit(input?.limit);
+    return {
+        page,
+        limit,
+        offset: calculateOffset(page, limit),
+    };
+}
+/**
+ * Normalizes a page number.
+ */
+export function normalizePage(page) {
+    if (page === undefined || !Number.isFinite(page)) {
+        return DEFAULT_PAGE;
+    }
+    return Math.max(1, Math.floor(page));
+}
+/**
+ * Normalizes a page size.
+ */
+export function normalizeLimit(limit) {
+    if (limit === undefined || !Number.isFinite(limit)) {
+        return DEFAULT_LIMIT;
+    }
+    return Math.min(MAX_LIMIT, Math.max(1, Math.floor(limit)));
+}
+/**
+ * Calculates the database offset for a page.
+ */
+export function calculateOffset(page, limit) {
+    return (normalizePage(page) - 1) * normalizeLimit(limit);
+}
+/**
+ * Calculates the total number of pages.
+ */
+export function calculateTotalPages(total, limit) {
+    const normalizedTotal = Math.max(0, Math.floor(total));
+    const normalizedLimit = normalizeLimit(limit);
+    if (normalizedTotal === 0) {
+        return 0;
+    }
+    return Math.ceil(normalizedTotal / normalizedLimit);
+}
+/**
+ * Creates pagination metadata.
+ */
+export function createPaginationMeta(page, limit, total) {
+    const normalizedPage = normalizePage(page);
+    const normalizedLimit = normalizeLimit(limit);
+    const normalizedTotal = Math.max(0, Math.floor(total));
+    const totalPages = calculateTotalPages(normalizedTotal, normalizedLimit);
+    const hasNextPage = totalPages > 0 && normalizedPage < totalPages;
+    const hasPreviousPage = normalizedPage > 1 && totalPages > 0;
+    return {
+        page: normalizedPage,
+        limit: normalizedLimit,
+        total: normalizedTotal,
+        totalPages,
+        hasNextPage,
+        hasPreviousPage,
+        hasNext: hasNextPage,
+        hasPrev: hasPreviousPage,
+    };
+}
+/**
+ * Creates a paginated result.
+ */
+export function createPaginatedResult(data, page, limit, total) {
+    return {
+        data: [...data],
+        meta: createPaginationMeta(page, limit, total),
+    };
+}
+/**
+ * Gets the next page number.
+ */
+export function getNextPage(meta) {
+    if (!meta.hasNextPage) {
+        return null;
+    }
+    return meta.page + 1;
+}
+/**
+ * Gets the previous page number.
+ */
+export function getPreviousPage(meta) {
+    if (!meta.hasPreviousPage) {
+        return null;
+    }
+    return Math.max(1, meta.page - 1);
+}
+/**
+ * Checks whether a page number is valid for the result set.
+ */
+export function isValidPage(page, totalPages) {
+    if (!Number.isFinite(page) || !Number.isFinite(totalPages)) {
+        return false;
+    }
+    const normalizedPage = Math.floor(page);
+    const normalizedTotalPages = Math.max(0, Math.floor(totalPages));
+    if (normalizedTotalPages === 0) {
+        return normalizedPage === 1;
+    }
+    return normalizedPage >= 1 && normalizedPage <= normalizedTotalPages;
+}
+/**
+ * Calculates the item range represented by a page.
+ *
+ * For example, page 2 with a limit of 20 and total of 55 returns
+ * `{ start: 21, end: 40 }`.
+ */
+export function getItemRange(page, limit, total) {
+    const normalizedPage = normalizePage(page);
+    const normalizedLimit = normalizeLimit(limit);
+    const normalizedTotal = Math.max(0, Math.floor(total));
+    if (normalizedTotal === 0) {
+        return {
+            start: 0,
+            end: 0,
+        };
+    }
+    const start = calculateOffset(normalizedPage, normalizedLimit) + 1;
+    const end = Math.min(start + normalizedLimit - 1, normalizedTotal);
+    if (start > normalizedTotal) {
+        // The page lies past the end of the data set: there is no item range.
+        return {
+            start: 0,
+            end: 0,
+        };
+    }
+    return {
+        start,
+        end,
+    };
+}
+/**
+ * Applies offset pagination to an in-memory collection.
+ *
+ * This is useful for adapters and tests that need the same pagination
+ * semantics without querying the database directly.
+ */
+export function paginateCollection(items, input) {
+    const pagination = normalizePagination(input);
+    const total = items.length;
+    const data = items.slice(pagination.offset, pagination.offset + pagination.limit);
+    return createPaginatedResult(data, pagination.page, pagination.limit, total);
+}
+/**
+ * Normalizes cursor pagination input.
+ */
+export function normalizeCursorPagination(input) {
+    return {
+        cursor: input?.cursor ?? null,
+        limit: normalizeLimit(input?.limit),
+    };
+}
+/**
+ * Creates cursor pagination metadata.
+ */
+export function createCursorPaginationMeta(limit, options) {
+    return {
+        limit: normalizeLimit(limit),
+        hasNextPage: options.hasNextPage,
+        hasPreviousPage: options.hasPreviousPage ?? false,
+        nextCursor: options.nextCursor ?? undefined,
+        previousCursor: options.previousCursor ?? undefined,
+    };
+}
+/**
+ * Creates a cursor paginated result.
+ */
+export function createCursorPaginatedResult(data, limit, options) {
+    return {
+        data: [...data],
+        meta: createCursorPaginationMeta(limit, options),
+    };
+}
+const CURSOR_SIGNATURE_SEPARATOR = ".";
+const FORBIDDEN_CURSOR_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+/**
+ * Encodes a cursor value.
+ *
+ * Without a `secret` the cursor is plain base64url JSON and must be treated
+ * as client-controlled input; pass `allowedFields` to `decodeCursor` (or
+ * use a secret) before feeding it to a query.
+ */
+export function encodeCursor(value, options = {}) {
+    const serialized = JSON.stringify(value);
+    if (typeof serialized !== "string") {
+        throw new TypeError("Cursor value could not be serialized.");
+    }
+    const payload = Buffer.from(serialized, "utf8").toString("base64url");
+    if (options.secret === undefined) {
+        return payload;
+    }
+    validateSecret(options.secret);
+    return `${payload}${CURSOR_SIGNATURE_SEPARATOR}${signCursor(payload, options.secret)}`;
+}
+/**
+ * Decodes a cursor value.
+ *
+ * When `secret` is supplied the signature is verified; when
+ * `allowedFields` is supplied the payload must be a flat object whose keys
+ * are all allowed and whose values are primitives.
+ */
+export function decodeCursor(cursor, options = {}) {
+    if (typeof cursor !== "string" || cursor.trim().length === 0) {
+        throw new TypeError("A cursor value is required.");
+    }
+    let payload = cursor;
+    if (options.secret !== undefined) {
+        validateSecret(options.secret);
+        const separator = cursor.lastIndexOf(CURSOR_SIGNATURE_SEPARATOR);
+        if (separator <= 0) {
+            throw new TypeError("Invalid pagination cursor signature.");
+        }
+        payload = cursor.slice(0, separator);
+        const signature = cursor.slice(separator + 1);
+        const expected = signCursor(payload, options.secret);
+        if (signature.length !== expected.length ||
+            !timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) {
+            throw new TypeError("Invalid pagination cursor signature.");
+        }
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+    }
+    catch (error) {
+        throw new TypeError("Invalid pagination cursor.", {
+            cause: error,
+        });
+    }
+    if (options.allowedFields !== undefined) {
+        validateCursorPayload(decoded, options.allowedFields);
+    }
+    return decoded;
+}
+/**
+ * Validates that a decoded cursor is a flat object of primitive values
+ * restricted to the allowed fields.
+ */
+export function validateCursorPayload(value, allowedFields) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError("Pagination cursor payload must be an object.");
+    }
+    const allowed = new Set(allowedFields);
+    for (const [key, entry] of Object.entries(value)) {
+        if (FORBIDDEN_CURSOR_KEYS.has(key) || !allowed.has(key)) {
+            throw new TypeError(`Pagination cursor contains an unexpected field "${key}".`);
+        }
+        if (entry !== null &&
+            typeof entry !== "string" &&
+            typeof entry !== "number" &&
+            typeof entry !== "boolean") {
+            throw new TypeError(`Pagination cursor field "${key}" must be a primitive value.`);
+        }
+    }
+}
+function signCursor(payload, secret) {
+    return createHmac("sha256", secret).update(payload).digest("base64url");
+}
+function validateSecret(secret) {
+    if (typeof secret !== "string" || secret.length === 0) {
+        throw new TypeError("A cursor secret must be a non-empty string.");
+    }
+}
+//# sourceMappingURL=pagination.core.js.map

package/dist/pagination/pagination.keyset.d.ts

@@ -0,0 +1,55 @@
+import type { SortInput } from "../databaseType/databaseType.type.js";
+import { type CursorPaginatedResult, type CursorPayload } from "./pagination.core.js";
+/**
+ * Options for building a keyset page.
+ */
+export interface KeysetPageOptions<TField extends string = string> {
+    /**
+     * The sort definition the rows were fetched with. The cursor is derived
+     * from these fields, in order.
+     */
+    readonly sort: readonly SortInput<TField>[];
+    /**
+     * The requested page size. Rows beyond this size indicate a next page.
+     */
+    readonly limit: number;
+    /**
+     * The cursor the page was requested with, if any.
+     */
+    readonly cursor?: string | null;
+    /**
+     * Secret used to sign cursors. Strongly recommended for public APIs.
+     */
+    readonly secret?: string;
+}
+/**
+ * A Prisma-style filter object produced by the keyset helpers.
+ */
+export type KeysetWhere = Readonly<Record<string, unknown>>;
+/**
+ * Decodes and validates a keyset cursor against the sort definition.
+ *
+ * The payload may only contain the sort fields and primitive values.
+ */
+export declare function decodeKeysetCursor<TField extends string = string>(cursor: string, sort: readonly SortInput<TField>[], secret?: string): CursorPayload;
+/**
+ * Builds a Prisma-compatible `where` fragment that selects the rows that
+ * come strictly after the cursor position in the given sort order.
+ *
+ * For a sort of `[a asc, b desc]` the result is
+ * `OR: [{ a: { gt: A } }, { AND: [{ a: A }, { b: { lt: B } }] }]`.
+ */
+export declare function buildKeysetWhere<TField extends string = string>(cursor: CursorPayload, sort: readonly SortInput<TField>[]): KeysetWhere;
+/**
+ * Derives the cursor payload for a row from the sort fields.
+ */
+export declare function createKeysetCursor<TField extends string = string>(row: Readonly<Record<string, unknown>>, sort: readonly SortInput<TField>[], secret?: string): string;
+/**
+ * Turns `limit + 1` fetched rows into a cursor-paginated result.
+ *
+ * Fetch `limit + 1` rows ordered by `sort`, then pass them here: the extra
+ * row signals a next page and is dropped, and `nextCursor` is derived from
+ * the last returned row.
+ */
+export declare function createKeysetPage<TEntity extends Readonly<Record<string, unknown>>, TField extends string = string>(rows: readonly TEntity[], options: KeysetPageOptions<TField>): CursorPaginatedResult<TEntity>;
+//# sourceMappingURL=pagination.keyset.d.ts.map

package/dist/pagination/pagination.keyset.js

@@ -0,0 +1,108 @@
+import { createCursorPaginatedResult, decodeCursor, encodeCursor, normalizeLimit, } from "./pagination.core.js";
+/**
+ * Decodes and validates a keyset cursor against the sort definition.
+ *
+ * The payload may only contain the sort fields and primitive values.
+ */
+export function decodeKeysetCursor(cursor, sort, secret) {
+    validateSort(sort);
+    const payload = decodeCursor(cursor, {
+        secret,
+        allowedFields: sort.map((entry) => entry.field),
+    });
+    for (const entry of sort) {
+        if (!(entry.field in payload)) {
+            throw new TypeError(`Pagination cursor is missing sort field "${entry.field}".`);
+        }
+    }
+    return payload;
+}
+/**
+ * Builds a Prisma-compatible `where` fragment that selects the rows that
+ * come strictly after the cursor position in the given sort order.
+ *
+ * For a sort of `[a asc, b desc]` the result is
+ * `OR: [{ a: { gt: A } }, { AND: [{ a: A }, { b: { lt: B } }] }]`.
+ */
+export function buildKeysetWhere(cursor, sort) {
+    validateSort(sort);
+    const branches = [];
+    sort.forEach((entry, index) => {
+        const comparison = entry.direction === "desc" ? "lt" : "gt";
+        const conditions = sort
+            .slice(0, index)
+            .map((previous) => ({
+            [previous.field]: { equals: cursor[previous.field] },
+        }));
+        conditions.push({
+            [entry.field]: { [comparison]: cursor[entry.field] },
+        });
+        branches.push(conditions.length === 1 ? conditions[0] : { AND: conditions });
+    });
+    return branches.length === 1 ? branches[0] : { OR: branches };
+}
+/**
+ * Derives the cursor payload for a row from the sort fields.
+ */
+export function createKeysetCursor(row, sort, secret) {
+    validateSort(sort);
+    const payload = {};
+    for (const entry of sort) {
+        payload[entry.field] = toCursorValue(row[entry.field], entry.field);
+    }
+    return encodeCursor(payload, { secret });
+}
+/**
+ * Turns `limit + 1` fetched rows into a cursor-paginated result.
+ *
+ * Fetch `limit + 1` rows ordered by `sort`, then pass them here: the extra
+ * row signals a next page and is dropped, and `nextCursor` is derived from
+ * the last returned row.
+ */
+export function createKeysetPage(rows, options) {
+    const limit = normalizeLimit(options.limit);
+    const hasNextPage = rows.length > limit;
+    const data = rows.slice(0, limit);
+    const last = data[data.length - 1];
+    return createCursorPaginatedResult(data, limit, {
+        hasNextPage,
+        hasPreviousPage: options.cursor !== undefined && options.cursor !== null,
+        nextCursor: hasNextPage && last
+            ? createKeysetCursor(last, options.sort, options.secret)
+            : null,
+    });
+}
+function toCursorValue(value, field) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    throw new TypeError(`Cannot build a cursor from field "${field}": unsupported value type.`);
+}
+function validateSort(sort) {
+    if (!Array.isArray(sort) || sort.length === 0) {
+        throw new TypeError("Keyset pagination requires at least one sort field.");
+    }
+    const seen = new Set();
+    for (const entry of sort) {
+        if (typeof entry.field !== "string" || entry.field.trim().length === 0) {
+            throw new TypeError("Keyset sort fields must be non-empty strings.");
+        }
+        if (entry.direction !== "asc" && entry.direction !== "desc") {
+            throw new TypeError(`Keyset sort field "${entry.field}" has an invalid direction.`);
+        }
+        if (seen.has(entry.field)) {
+            throw new TypeError(`Keyset sort field "${entry.field}" is duplicated.`);
+        }
+        seen.add(entry.field);
+    }
+}
+//# sourceMappingURL=pagination.keyset.js.map

package/dist/queryBuilder/index.d.ts

@@ -4,7 +4,8 @@
  * Database-neutral query construction and filter helpers.
  */
 export { QueryBuilder } from "./queryBuilder.core.js";
-export { createQueryBuilder, cloneFilter } from "./queryBuilder.factory.js";
-export type { QueryCondition, QueryFilter, QueryOperator, QueryBuilderState, } from "./queryBuilder.type.js";
-export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, } from "./queryBuilder.filter.js";
+export { createQueryBuilder } from "./queryBuilder.factory.js";
+export { toPrismaWhere, toPrismaArgs, toPrismaOrderBy, toPrismaSelect, toPrismaSkipTake, type PrismaWhere, type PrismaQueryArgs, type ToPrismaArgsOptions, } from "./queryBuilder.prisma.js";
+export type { QueryCondition, QueryFilter, QueryOperator, RelationOperator, QueryBuilderState, } from "./queryBuilder.type.js";
+export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, cloneFilter, between, matchesPattern, isEmpty, isNotEmpty, dateOnly, isBefore, isAfter, isBetween, notCondition, relational, } from "./queryBuilder.filter.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/queryBuilder/index.js

@@ -4,6 +4,7 @@
  * Database-neutral query construction and filter helpers.
  */
 export { QueryBuilder } from "./queryBuilder.core.js";
-export { createQueryBuilder, cloneFilter } from "./queryBuilder.factory.js";
-export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, } from "./queryBuilder.filter.js";
+export { createQueryBuilder } from "./queryBuilder.factory.js";
+export { toPrismaWhere, toPrismaArgs, toPrismaOrderBy, toPrismaSelect, toPrismaSkipTake, } from "./queryBuilder.prisma.js";
+export { equals, notEquals, inList, notInList, lessThan, lessThanOrEqual, greaterThan, greaterThanOrEqual, contains, startsWith, endsWith, isNull, isNotNull, and, or, not, condition, allOf, anyOf, fromObject, dateRange, oneOf, noneOf, optionalEquals, optionalContains, hasConditions, flattenAnd, cloneFilter, between, matchesPattern, isEmpty, isNotEmpty, dateOnly, isBefore, isAfter, isBetween, notCondition, relational, } from "./queryBuilder.filter.js";
 //# sourceMappingURL=index.js.map