feat: make ilike postgres-specific via trait-targeted extension operations

Move ilike from a core comparison method to a postgres adapter-provided
extension operation. Operation args now support targeting by trait
(e.g., `traits: ['textual']`) in addition to codecId, allowing
adapter operations to match any codec with the required traits.

- Extend ParamSpec and QueryOperationArgSpec with optional `traits` field
- Add FieldSpec/TraitField to sql-builder scope for trait-targeted expressions
- Update FieldOperations type matching to support trait-based operations
- Boolean-trait return detection makes predicate ops return AnyExpression
- Register ilike in postgres adapter's queryOperations()
- Remove ilike from BinaryOp union, BinaryExpr, ComparisonMethodFns
- Remove ilike runtime guard from SQLite adapter
- Fix tsdown exports stripping ./schema-sql in sql-contract-ts

Author: SevInf

examples/prisma-next-demo/src/prisma/contract.d.ts

@@ -16,6 +16,7 @@ import type { Interval } from '@prisma-next/adapter-postgres/codec-types';
 import type { CodecTypes as PgVectorTypes } from '@prisma-next/extension-pgvector/codec-types';
 import type { Vector } from '@prisma-next/extension-pgvector/codec-types';
 import type { OperationTypes as PgVectorOperationTypes } from '@prisma-next/extension-pgvector/operation-types';
+import type { QueryOperationTypes as PgAdapterQueryOps } from '@prisma-next/adapter-postgres/operation-types';
 import type { QueryOperationTypes as PgVectorQueryOperationTypes } from '@prisma-next/extension-pgvector/operation-types';
 
 import type {
@@ -39,7 +40,7 @@ export type ProfileHash =
 export type CodecTypes = PgTypes & PgVectorTypes;
 export type OperationTypes = PgVectorOperationTypes;
 export type LaneCodecTypes = CodecTypes;
-export type QueryOperationTypes = PgVectorQueryOperationTypes;
+export type QueryOperationTypes = PgAdapterQueryOps & PgVectorQueryOperationTypes;
 type DefaultLiteralValue<CodecId extends string, _Encoded> = CodecId extends keyof CodecTypes
   ? CodecTypes[CodecId]['output']
   : _Encoded;

packages/1-framework/1-core/operations/src/index.ts

@@ -1,11 +1,17 @@
 export interface ParamSpec {
+  readonly codecId?: string;
+  readonly traits?: readonly string[];
+  readonly nullable: boolean;
+}
+
+export interface ReturnSpec {
   readonly codecId: string;
   readonly nullable: boolean;
 }
 
 export interface OperationEntry {
   readonly args: readonly ParamSpec[];
-  readonly returns: ParamSpec;
+  readonly returns: ReturnSpec;
 }
 
 export type OperationDescriptor<T extends OperationEntry = OperationEntry> = T & {

packages/2-sql/1-core/contract/src/exports/types.ts

@@ -12,6 +12,7 @@ export type {
   Index,
   OperationTypesOf,
   PrimaryKey,
+  QueryOperationArgSpec,
   QueryOperationTypeEntry,
   QueryOperationTypesBase,
   QueryOperationTypesOf,

packages/2-sql/1-core/contract/src/types.ts

@@ -1,4 +1,5 @@
 import type { ColumnDefault, StorageBase } from '@prisma-next/contract/types';
+import type { CodecTrait } from '@prisma-next/framework-components/codec';
 
 /**
  * A column definition in storage.
@@ -164,8 +165,14 @@ export type OperationTypesOf<T> = [T] extends [never]
       : Record<string, never>
     : Record<string, never>;
 
+export type QueryOperationArgSpec = {
+  readonly codecId?: string;
+  readonly traits?: CodecTrait;
+  readonly nullable: boolean;
+};
+
 export type QueryOperationTypeEntry = {
-  readonly args: readonly { readonly codecId: string; readonly nullable: boolean }[];
+  readonly args: readonly QueryOperationArgSpec[];
   readonly returns: { readonly codecId: string; readonly nullable: boolean };
 };
 

packages/2-sql/4-lanes/relational-core/src/ast/types.ts

@@ -4,17 +4,7 @@ import type { SqlLoweringSpec } from '@prisma-next/sql-operations';
 
 export type Direction = 'asc' | 'desc';
 
-export type BinaryOp =
-  | 'eq'
-  | 'neq'
-  | 'gt'
-  | 'lt'
-  | 'gte'
-  | 'lte'
-  | 'like'
-  | 'ilike'
-  | 'in'
-  | 'notIn';
+export type BinaryOp = 'eq' | 'neq' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'in' | 'notIn';
 
 export type AggregateCountFn = 'count';
 export type AggregateOpFn = 'sum' | 'avg' | 'min' | 'max';
@@ -801,10 +791,6 @@ export class BinaryExpr extends Expression {
     return new BinaryExpr('like', left, right);
   }
 
-  static ilike(left: AnyExpression, right: AnyExpression): BinaryExpr {
-    return new BinaryExpr('ilike', left, right);
-  }
-
   static in(left: AnyExpression, right: AnyExpression): BinaryExpr {
     return new BinaryExpr('in', left, right);
   }

packages/2-sql/4-lanes/relational-core/test/ast/predicate.test.ts

@@ -29,7 +29,6 @@ describe('ast/predicate', () => {
     'gte',
     'lte',
     'like',
-    'ilike',
     'in',
     'notIn',
   ] as const)('stores the %s operator', (op) => {

packages/2-sql/4-lanes/sql-builder/src/expression.ts

@@ -2,14 +2,15 @@ import type { QueryOperationTypesBase } from '@prisma-next/sql-contract/types';
 import type {
   Expand,
   ExpressionType,
+  FieldSpec,
   QueryContext,
   Scope,
   ScopeField,
   ScopeTable,
   Subquery,
 } from './scope';
 
-export type Expression<T extends ScopeField> = {
+export type Expression<T extends FieldSpec> = {
   [ExpressionType]: T;
   buildAst(): import('@prisma-next/sql-relational-core/ast').AnyExpression;
 };
@@ -66,10 +67,33 @@ export type OrderByScope<
   namespaces: AvailableScope['namespaces'];
 };
 
+type CodecIdsWithTrait<
+  CT extends Record<string, { readonly input: unknown }>,
+  Trait extends string,
+> = {
+  [K in keyof CT & string]: CT[K] extends { readonly traits: infer T }
+    ? Trait extends T
+      ? K
+      : never
+    : never;
+}[keyof CT & string];
+
+type ResolveExtArg<Arg, CT extends Record<string, { readonly input: unknown }>> = Arg extends {
+  readonly codecId: infer CId extends string;
+  readonly nullable: infer N extends boolean;
+}
+  ? ExpressionOrValue<{ codecId: CId; nullable: N }, CT>
+  : Arg extends {
+        readonly traits: infer T extends string;
+        readonly nullable: infer N extends boolean;
+      }
+    ? Expression<{ codecId: CodecIdsWithTrait<CT, T>; nullable: N }>
+    : never;
+
 type ExtensionFunctionArgs<
-  Args extends readonly ScopeField[],
+  Args extends readonly unknown[],
   CT extends Record<string, { readonly input: unknown }>,
-> = { [I in keyof Args]: ExpressionOrValue<Args[I], CT> };
+> = { [I in keyof Args]: ResolveExtArg<Args[I], CT> };
 
 type DeriveExtFunctions<
   OT extends QueryOperationTypesBase,

packages/2-sql/4-lanes/sql-builder/src/scope.ts

@@ -14,6 +14,8 @@ export type Expand<T> = { [K in keyof T]: T[K] } & unknown;
 export type EmptyRow = Record<never, ScopeField>;
 
 export type ScopeField = { codecId: string; nullable: boolean };
+export type TraitField = { traits: string; nullable: boolean };
+export type FieldSpec = ScopeField | TraitField;
 export type ScopeTable = Record<string, ScopeField>;
 
 export type Scope = {

packages/2-sql/4-lanes/sql-builder/test/fixtures/generated/contract.d.ts

@@ -16,6 +16,7 @@ import type { Interval } from '@prisma-next/adapter-postgres/codec-types';
 import type { CodecTypes as PgVectorTypes } from '@prisma-next/extension-pgvector/codec-types';
 import type { Vector } from '@prisma-next/extension-pgvector/codec-types';
 import type { OperationTypes as PgVectorOperationTypes } from '@prisma-next/extension-pgvector/operation-types';
+import type { QueryOperationTypes as PgAdapterQueryOps } from '@prisma-next/adapter-postgres/operation-types';
 import type { QueryOperationTypes as PgVectorQueryOperationTypes } from '@prisma-next/extension-pgvector/operation-types';
 
 import type {
@@ -39,7 +40,7 @@ export type ProfileHash =
 export type CodecTypes = PgTypes & PgVectorTypes;
 export type OperationTypes = PgVectorOperationTypes;
 export type LaneCodecTypes = CodecTypes;
-export type QueryOperationTypes = PgVectorQueryOperationTypes;
+export type QueryOperationTypes = PgAdapterQueryOps & PgVectorQueryOperationTypes;
 type DefaultLiteralValue<CodecId extends string, _Encoded> = CodecId extends keyof CodecTypes
   ? CodecTypes[CodecId]['output']
   : _Encoded;

packages/2-sql/4-lanes/sql-builder/test/integration/extension-functions.test.ts

@@ -1,6 +1,31 @@
 import { describe, expect, it } from 'vitest';
 import { setupIntegrationTest } from './setup';
 
+describe('integration: ilike (adapter operation)', () => {
+  const { db, runtime } = setupIntegrationTest();
+
+  it('ilike filters case-insensitively in WHERE', async () => {
+    const rows = await runtime().execute(
+      db()
+        .users.select('id', 'name')
+        .where((f, fns) => fns.ilike(f.name, '%alice%'))
+        .build(),
+    );
+    expect(rows).toHaveLength(1);
+    expect(rows[0]!.name).toBe('Alice');
+  });
+
+  it('ilike returns no rows when pattern does not match', async () => {
+    const rows = await runtime().execute(
+      db()
+        .users.select('id')
+        .where((f, fns) => fns.ilike(f.name, '%zzz%'))
+        .build(),
+    );
+    expect(rows).toHaveLength(0);
+  });
+});
+
 describe('integration: extension functions', () => {
   const { db, runtime } = setupIntegrationTest();