kitcn 0.24.0 → 0.25.0

package/dist/filter-expression-Dydt8wS0.js

@@ -0,0 +1,402 @@
+//#region src/orm/filter-expression.ts
+/**
+* Unique symbol for FilterExpression brand
+* Prevents structural typing - only expressions created by factory functions are valid
+*/
+const FilterExpressionBrand = Symbol("FilterExpression");
+/**
+* Create a field reference
+* Used internally by operator functions
+*/
+function fieldRef(fieldName) {
+	return {
+		__brand: "FieldReference",
+		fieldName
+	};
+}
+/**
+* Type guard for FieldReference
+*/
+function isFieldReference(value) {
+	return value && typeof value === "object" && value.__brand === "FieldReference";
+}
+/**
+* The pattern is the same for every row of a scan while the value is not, so
+* only the value genuinely has to be split per call. A small bounded cache
+* keeps the split pattern across rows without unbounded growth on
+* caller-supplied patterns; a query with a handful of LIKE filters still hits
+* on every row.
+*/
+const LIKE_PATTERN_CACHE_MAX = 16;
+const likePatternCache = /* @__PURE__ */ new Map();
+function likePatternCodePoints(pattern, caseInsensitive) {
+	const key = caseInsensitive ? `i:${pattern}` : `s:${pattern}`;
+	const cached = likePatternCache.get(key);
+	if (cached) return cached;
+	const source = Array.from(caseInsensitive ? pattern.toLowerCase() : pattern);
+	if (likePatternCache.size >= LIKE_PATTERN_CACHE_MAX) for (const oldest of likePatternCache.keys()) {
+		likePatternCache.delete(oldest);
+		break;
+	}
+	likePatternCache.set(key, source);
+	return source;
+}
+/**
+* SQL `LIKE` semantics: `%` matches any run of characters, `_` matches exactly
+* one, everything else is literal. Wildcards work anywhere in the pattern, not
+* only at the ends.
+*
+* Matched with a single-backtrack scan rather than a compiled regex. A pattern
+* is caller data — anything interpolated into `` `%${query}%` `` reaches here —
+* and translating `%` to a regex quantifier makes `'%%%%%z'` backtrack
+* exponentially, which would burn the whole Convex function CPU budget on one
+* row. This scan remembers only the most recent `%`, so the worst case is
+* O(value * pattern) with no catastrophic case at all.
+*/
+function matchLikePattern(value, pattern, caseInsensitive) {
+	const target = Array.from(caseInsensitive ? value.toLowerCase() : value);
+	const source = likePatternCodePoints(pattern, caseInsensitive);
+	let valueIndex = 0;
+	let patternIndex = 0;
+	let wildcardPatternIndex = -1;
+	let wildcardValueIndex = 0;
+	while (valueIndex < target.length) {
+		const patternChar = patternIndex < source.length ? source[patternIndex] : void 0;
+		if (patternChar === "_" || patternChar === target[valueIndex]) {
+			valueIndex += 1;
+			patternIndex += 1;
+		} else if (patternChar === "%") {
+			wildcardPatternIndex = patternIndex;
+			wildcardValueIndex = valueIndex;
+			patternIndex += 1;
+		} else if (wildcardPatternIndex === -1) return false;
+		else {
+			wildcardValueIndex += 1;
+			valueIndex = wildcardValueIndex;
+			patternIndex = wildcardPatternIndex + 1;
+		}
+	}
+	while (patternIndex < source.length && source[patternIndex] === "%") patternIndex += 1;
+	return patternIndex === source.length;
+}
+/**
+* Structural equality matching Convex's own `q.eq`. Arrays, objects and bytes
+* are compared by content: reference identity would make every `eq`/`in` filter
+* on a `custom(v.array(...))` / `custom(v.object(...))` column match nothing.
+*/
+function filterValuesEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+	if (Array.isArray(a) || Array.isArray(b)) {
+		if (!(Array.isArray(a) && Array.isArray(b)) || a.length !== b.length) return false;
+		return a.every((item, index) => filterValuesEqual(item, b[index]));
+	}
+	if (a instanceof ArrayBuffer || b instanceof ArrayBuffer) {
+		if (!(a instanceof ArrayBuffer && b instanceof ArrayBuffer) || a.byteLength !== b.byteLength) return false;
+		const left = new Uint8Array(a);
+		const right = new Uint8Array(b);
+		return left.every((byte, index) => byte === right[index]);
+	}
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	if (aKeys.length !== bKeys.length) return false;
+	return aKeys.every((key) => Object.hasOwn(b, key) && filterValuesEqual(a[key], b[key]));
+}
+/** `inArray`/`notInArray` membership using {@link filterValuesEqual}. */
+function filterValueInList(value, list) {
+	return list.some((candidate) => filterValuesEqual(candidate, value));
+}
+/**
+* Create a column wrapper
+* Used internally by query builder's _createColumnProxies
+*/
+function column(builder, columnName) {
+	return {
+		builder,
+		columnName
+	};
+}
+function resolveColumn(col) {
+	if (col && typeof col === "object" && "columnName" in col) return col;
+	if (isFieldReference(col)) return {
+		builder: col,
+		columnName: col.fieldName
+	};
+	const builder = col;
+	const columnName = builder?.config?.name;
+	if (!columnName) throw new Error("Column builder is missing a column name");
+	return column(builder, columnName);
+}
+/**
+* Internal binary expression implementation
+* Private class - only accessible via factory functions
+*/
+var BinaryExpressionImpl = class {
+	[FilterExpressionBrand] = true;
+	type = "binary";
+	constructor(operator, operands) {
+		this.operator = operator;
+		this.operands = operands;
+	}
+	accept(visitor) {
+		return visitor.visitBinary(this);
+	}
+};
+/**
+* Internal logical expression implementation
+* Private class - only accessible via factory functions
+*/
+var LogicalExpressionImpl = class {
+	[FilterExpressionBrand] = true;
+	type = "logical";
+	constructor(operator, operands) {
+		this.operator = operator;
+		this.operands = operands;
+	}
+	accept(visitor) {
+		return visitor.visitLogical(this);
+	}
+};
+/**
+* Internal unary expression implementation
+* Private class - only accessible via factory functions
+*/
+var UnaryExpressionImpl = class {
+	[FilterExpressionBrand] = true;
+	type = "unary";
+	constructor(operator, operands) {
+		this.operator = operator;
+		this.operands = operands;
+	}
+	accept(visitor) {
+		return visitor.visitUnary(this);
+	}
+};
+/**
+* Equality operator: field == value
+*
+* @example
+* const filter = eq(cols.name, 'Alice');
+*/
+function eq(col, value) {
+	return new BinaryExpressionImpl("eq", [fieldRef(resolveColumn(col).columnName), value]);
+}
+/**
+* Not equal operator: field != value
+*/
+function ne(col, value) {
+	return new BinaryExpressionImpl("ne", [fieldRef(resolveColumn(col).columnName), value]);
+}
+/**
+* Greater than operator: field > value
+*/
+function gt(col, value) {
+	return new BinaryExpressionImpl("gt", [fieldRef(resolveColumn(col).columnName), value]);
+}
+/**
+* Greater than or equal operator: field >= value
+*/
+function gte(col, value) {
+	return new BinaryExpressionImpl("gte", [fieldRef(resolveColumn(col).columnName), value]);
+}
+/**
+* Less than operator: field < value
+*/
+function lt(col, value) {
+	return new BinaryExpressionImpl("lt", [fieldRef(resolveColumn(col).columnName), value]);
+}
+/**
+* Less than or equal operator: field <= value
+*/
+function lte(col, value) {
+	return new BinaryExpressionImpl("lte", [fieldRef(resolveColumn(col).columnName), value]);
+}
+/**
+* Between operator: field BETWEEN min AND max (inclusive)
+*
+* Sugar for and(gte(field, min), lte(field, max)).
+*/
+function between(col, min, max) {
+	return and(gte(col, min), lte(col, max));
+}
+/**
+* Not between operator: field < min OR field > max
+*
+* Sugar for or(lt(field, min), gt(field, max)).
+*/
+function notBetween(col, min, max) {
+	return or(lt(col, min), gt(col, max));
+}
+/**
+* LIKE operator: SQL-style pattern matching with % wildcards
+* Note: Implemented as post-filter (Convex has no native LIKE)
+*
+* @example
+* const users = await db.query.users.findMany({
+*   where: like(users.name, '%alice%'),
+* });
+*/
+function like(col, pattern) {
+	return new BinaryExpressionImpl("like", [fieldRef(resolveColumn(col).columnName), pattern]);
+}
+/**
+* ILIKE operator: Case-insensitive LIKE
+* Note: Implemented as post-filter (Convex has no native LIKE)
+*
+* @example
+* const users = await db.query.users.findMany({
+*   where: ilike(users.name, '%ALICE%'),
+* });
+*/
+function ilike(col, pattern) {
+	return new BinaryExpressionImpl("ilike", [fieldRef(resolveColumn(col).columnName), pattern]);
+}
+/**
+* NOT LIKE operator: Negated LIKE pattern
+*/
+function notLike(col, pattern) {
+	return new BinaryExpressionImpl("notLike", [fieldRef(resolveColumn(col).columnName), pattern]);
+}
+/**
+* NOT ILIKE operator: Negated case-insensitive LIKE
+*/
+function notIlike(col, pattern) {
+	return new BinaryExpressionImpl("notIlike", [fieldRef(resolveColumn(col).columnName), pattern]);
+}
+/**
+* startsWith operator: Check if string starts with prefix
+* Optimized for prefix matching
+*
+* @example
+* const users = await db.query.users.findMany({
+*   where: startsWith(users.email, 'admin@'),
+* });
+*/
+function startsWith(col, prefix) {
+	return new BinaryExpressionImpl("startsWith", [fieldRef(resolveColumn(col).columnName), prefix]);
+}
+/**
+* endsWith operator: Check if string ends with suffix
+*
+* @example
+* const users = await db.query.users.findMany({
+*   where: endsWith(users.email, '@example.com'),
+* });
+*/
+function endsWith(col, suffix) {
+	return new BinaryExpressionImpl("endsWith", [fieldRef(resolveColumn(col).columnName), suffix]);
+}
+/**
+* contains operator: Check if string contains substring
+* Can use search index for optimization when available
+*
+* @example
+* const posts = await db.query.posts.findMany({
+*   where: contains(posts.title, 'javascript'),
+* });
+*/
+function contains(col, substring) {
+	return new BinaryExpressionImpl("contains", [fieldRef(resolveColumn(col).columnName), substring]);
+}
+/**
+* Logical AND: all expressions must be true
+* Filters out undefined expressions (following Drizzle pattern)
+*
+* @example
+* const filter = and(
+*   eq(fieldRef('age'), 25),
+*   eq(fieldRef('name'), 'Alice')
+* );
+*/
+function and(...expressions) {
+	const defined = expressions.filter((expr) => expr !== void 0);
+	if (defined.length === 0) return;
+	if (defined.length === 1) return defined[0];
+	return new LogicalExpressionImpl("and", defined);
+}
+/**
+* Logical OR: at least one expression must be true
+* Filters out undefined expressions (following Drizzle pattern)
+*
+* @example
+* const filter = or(
+*   eq(fieldRef('status'), 'active'),
+*   eq(fieldRef('status'), 'pending')
+* );
+*/
+function or(...expressions) {
+	const defined = expressions.filter((expr) => expr !== void 0);
+	if (defined.length === 0) return;
+	if (defined.length === 1) return defined[0];
+	return new LogicalExpressionImpl("or", defined);
+}
+/**
+* Logical NOT: negates expression
+*
+* @example
+* const filter = not(eq(fieldRef('isDeleted'), true));
+*/
+function not(expression) {
+	return new UnaryExpressionImpl("not", [expression]);
+}
+/**
+* Array membership operator: field IN array
+*
+* @example
+* const filter = inArray(cols.status, ['active', 'pending']);
+*/
+function inArray(col, values) {
+	return new BinaryExpressionImpl("inArray", [fieldRef(resolveColumn(col).columnName), values]);
+}
+/**
+* Array exclusion operator: field NOT IN array
+* Validates array is non-empty at construction time
+*
+* @example
+* const filter = notInArray(cols.role, ['admin', 'moderator']);
+*/
+function notInArray(col, values) {
+	if (!Array.isArray(values) || values.length === 0) throw new Error("notInArray requires a non-empty array of values");
+	return new BinaryExpressionImpl("notInArray", [fieldRef(resolveColumn(col).columnName), values]);
+}
+/**
+* Array contains operator: field @> array
+*/
+function arrayContains(col, values) {
+	return new BinaryExpressionImpl("arrayContains", [fieldRef(resolveColumn(col).columnName), values]);
+}
+/**
+* Array contained operator: field <@ array
+*/
+function arrayContained(col, values) {
+	return new BinaryExpressionImpl("arrayContained", [fieldRef(resolveColumn(col).columnName), values]);
+}
+/**
+* Array overlaps operator: field && array
+*/
+function arrayOverlaps(col, values) {
+	return new BinaryExpressionImpl("arrayOverlaps", [fieldRef(resolveColumn(col).columnName), values]);
+}
+/**
+* Null check operator: field IS NULL
+* Type validation: Only works with nullable fields
+*
+* @example
+* const filter = isNull(cols.deletedAt);
+*/
+function isNull(col) {
+	return new UnaryExpressionImpl("isNull", [fieldRef(resolveColumn(col).columnName)]);
+}
+/**
+* Not null check operator: field IS NOT NULL
+* Type validation: Only works with nullable fields
+*
+* @example
+* const filter = isNotNull(cols.deletedAt);
+*/
+function isNotNull(col) {
+	return new UnaryExpressionImpl("isNotNull", [fieldRef(resolveColumn(col).columnName)]);
+}
+
+//#endregion
+export { or as A, matchLikePattern as C, notIlike as D, notBetween as E, notInArray as O, lte as S, not as T, isFieldReference as _, between as a, like as b, endsWith as c, filterValueInList as d, filterValuesEqual as f, inArray as g, ilike as h, arrayOverlaps as i, startsWith as j, notLike as k, eq as l, gte as m, arrayContained as n, column as o, gt as p, arrayContains as r, contains as s, and as t, fieldRef as u, isNotNull as v, ne as w, lt as x, isNull as y };

package/dist/{generated-contract-disabled-B-nmd7Ne.d.ts → generated-contract-disabled-BEc4d98x.d.ts}

@@ -1,5 +1,5 @@
-import { t as GetAuth } from "./types-BCl8gfGy.js";
-import { t as GenericCtx } from "./context-utils-BBUtBqjN.js";
+import { t as GetAuth } from "./types-Bf3XQex5.js";
+import { t as GenericCtx } from "./context-utils-DwZ3Cam1.js";
 import * as convex_server0 from "convex/server";
 import { DocumentByName, FunctionReference, GenericDataModel, GenericMutationCtx, GenericSchema, PaginationResult, SchemaDefinition, TableNamesInDataModel, internalMutationGeneric } from "convex/server";
 import * as better_auth_adapters0 from "better-auth/adapters";

package/dist/{http-types-DXOgaerG.d.ts → http-types-90mapMP9.d.ts}

@@ -1,5 +1,5 @@
-import { o as Simplify } from "./types-DF2cg_w0.js";
-import { g as UnsetMarker, t as AnyMiddleware } from "./types-CnTpHR1F.js";
+import { o as Simplify } from "./types-MHYXboyy.js";
+import { g as UnsetMarker, t as AnyMiddleware } from "./types-eNzQmbqM.js";
 import { GenericActionCtx, GenericDataModel, HttpRouter } from "convex/server";
 import { z } from "zod";
 import { Context, Hono } from "hono";

package/dist/id-Bibg34Yb.js

@@ -0,0 +1,37 @@
+import { I as ConvexColumnBuilder, L as entityKind } from "./table-rmJm5Qio.js";
+import { v } from "convex/values";
+
+//#region src/orm/builders/id.ts
+/**
+* ID column builder class
+* Compiles to v.id(tableName) or v.optional(v.id(tableName))
+*/
+var ConvexIdBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexIdBuilder";
+	constructor(name, tableName) {
+		super(name, "string", "ConvexId");
+		this.tableName = tableName;
+		this.config.referenceTable = tableName;
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.id(this.tableName);
+		return v.optional(v.union(v.null(), v.id(this.tableName)));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.id(tableName)
+	* nullable → v.optional(v.id(tableName))
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function id(tableName) {
+	return new ConvexIdBuilder("", tableName);
+}
+
+//#endregion
+export { id as t };