TML-2354: unify SQL operations behind family-sql registry; break workspace build cycle

examples/prisma-next-demo/src/prisma-no-emit/context.ts

@@ -2,6 +2,7 @@ import postgresAdapter from '@prisma-next/adapter-postgres/runtime';
 import postgresDriver from '@prisma-next/driver-postgres/runtime';
 import pgvector from '@prisma-next/extension-pgvector/runtime';
 import { SqlContractSerializer } from '@prisma-next/family-sql/ir';
+import sqlRuntimeFamilyDescriptor from '@prisma-next/family-sql/runtime';
 import { sql as sqlBuilder } from '@prisma-next/sql-builder/runtime';
 import { orm } from '@prisma-next/sql-orm-client';
 import type { Runtime } from '@prisma-next/sql-runtime';
@@ -11,6 +12,7 @@ import { contract } from '../../prisma/contract';
 import { PostCollection, UserCollection } from '../orm-client/collections';
 
 export const stack = createSqlExecutionStack({
+  family: sqlRuntimeFamilyDescriptor,
   target: postgresTarget,
   adapter: postgresAdapter,
   driver: postgresDriver,

examples/prisma-next-demo/src/queries/cross-author-similarity.ts

@@ -33,15 +33,15 @@ import { db } from '../prisma/db';
  *
  * Features exercised:
  *   1. Self-join via `.as()` aliasing of the same table (`post` aliased as `p1` and `p2`).
- *   2. INNER JOIN with a non-equality predicate (`ne(p1.userId, p2.userId)`).
+ *   2. INNER JOIN with a non-equality predicate (`neq(p1.userId, p2.userId)`).
  *   3. pgvector `cosineDistance` called with two column references from two aliases — in the
  *      SELECT projection and in the ORDER BY.
  *   4. Typed result row inferred from the SELECT projection, mixing columns from both aliases.
  */
 export async function crossAuthorSimilarity(limit = 10, runtime?: Runtime) {
   const plan = db.sql.post
     .as('p1')
-    .innerJoin(db.sql.post.as('p2'), (f, fns) => fns.ne(f.p1.userId, f.p2.userId))
+    .innerJoin(db.sql.post.as('p2'), (f, fns) => fns.neq(f.p1.userId, f.p2.userId))
     .select((f, fns) => ({
       postAId: f.p1.id,
       postATitle: f.p1.title,
@@ -51,7 +51,7 @@ export async function crossAuthorSimilarity(limit = 10, runtime?: Runtime) {
       postBUserId: f.p2.userId,
       distance: fns.cosineDistance(f.p1.embedding, f.p2.embedding),
     }))
-    .where((f, fns) => fns.and(fns.ne(f.p1.embedding, null), fns.ne(f.p2.embedding, null)))
+    .where((f, fns) => fns.and(fns.neq(f.p1.embedding, null), fns.neq(f.p2.embedding, null)))
     .orderBy((f, fns) => fns.cosineDistance(f.p1.embedding, f.p2.embedding), {
       direction: 'asc',
     })

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

@@ -10,8 +10,9 @@ export interface ReturnSpec {
 }
 
 export type SelfSpec =
-  | { readonly codecId: string; readonly traits?: never }
-  | { readonly traits: readonly string[]; readonly codecId?: never };
+  | { readonly codecId: string; readonly traits?: never; readonly any?: never }
+  | { readonly traits: readonly string[]; readonly codecId?: never; readonly any?: never }
+  | { readonly any: true; readonly codecId?: never; readonly traits?: never };
 
 export interface OperationEntry {
   readonly self?: SelfSpec;
@@ -42,11 +43,15 @@ export function createOperationRegistry<
       if (descriptor.self) {
         const hasCodecId = descriptor.self.codecId !== undefined;
         const hasTraits = descriptor.self.traits !== undefined && descriptor.self.traits.length > 0;
-        if (!hasCodecId && !hasTraits) {
-          throw new Error(`Operation "${name}" self has neither codecId nor traits`);
+        const hasAny = descriptor.self.any === true;
+        if (!hasCodecId && !hasTraits && !hasAny) {
+          throw new Error(`Operation "${name}" self has none of codecId, traits, or any`);
         }
         if (hasCodecId && hasTraits) {
-          throw new Error(`Operation "${name}" self has both codecId and traits`);
+          throw new Error(`Operation "${name}" self combines codecId and traits`);
+        }
+        if (hasAny && (hasCodecId || hasTraits)) {
+          throw new Error(`Operation "${name}" self combines any with codecId or traits`);
         }
       }
       operations[name] = descriptor;

packages/1-framework/1-core/operations/test/operations-registry.test.ts

@@ -48,16 +48,16 @@ describe('OperationRegistry', () => {
     );
   });
 
-  it('throws when self has neither codecId nor traits', () => {
+  it('throws when self has none of codecId, traits, or any', () => {
     const registry = createOperationRegistry();
 
     expect(() =>
       registry.register('bad', {
-        // @ts-expect-error — SelfSpec requires codecId or traits
+        // @ts-expect-error — SelfSpec requires codecId, traits, or any
         self: {},
         impl: noopImpl,
       }),
-    ).toThrow('Operation "bad" self has neither codecId nor traits');
+    ).toThrow('Operation "bad" self has none of codecId, traits, or any');
   });
 
   it('throws when self has an empty traits array', () => {
@@ -68,19 +68,56 @@ describe('OperationRegistry', () => {
         self: { traits: [] },
         impl: noopImpl,
       }),
-    ).toThrow('Operation "bad" self has neither codecId nor traits');
+    ).toThrow('Operation "bad" self has none of codecId, traits, or any');
   });
 
-  it('throws when self has both codecId and traits', () => {
+  it('throws when self combines codecId and traits', () => {
     const registry = createOperationRegistry();
 
     expect(() =>
       registry.register('bad', {
-        // @ts-expect-error — SelfSpec disallows both codecId and traits
+        // @ts-expect-error — SelfSpec disallows combining codecId and traits
         self: { codecId: 'pg/text@1', traits: ['textual'] },
         impl: noopImpl,
       }),
-    ).toThrow('Operation "bad" self has both codecId and traits');
+    ).toThrow('Operation "bad" self combines codecId and traits');
+  });
+
+  it('accepts self with any: true', () => {
+    const registry = createOperationRegistry();
+
+    expect(() =>
+      registry.register(
+        'fine',
+        descriptor({
+          self: { any: true },
+        }),
+      ),
+    ).not.toThrow();
+  });
+
+  it('throws when self combines any with codecId', () => {
+    const registry = createOperationRegistry();
+
+    expect(() =>
+      registry.register('bad', {
+        // @ts-expect-error — SelfSpec disallows combining any with codecId
+        self: { any: true, codecId: 'pg/text@1' },
+        impl: noopImpl,
+      }),
+    ).toThrow('Operation "bad" self combines any with codecId or traits');
+  });
+
+  it('throws when self combines any with traits', () => {
+    const registry = createOperationRegistry();
+
+    expect(() =>
+      registry.register('bad', {
+        // @ts-expect-error — SelfSpec disallows combining any with traits
+        self: { any: true, traits: ['textual'] },
+        impl: noopImpl,
+      }),
+    ).toThrow('Operation "bad" self combines any with codecId or traits');
   });
 
   it('accepts trait-only self', () => {

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

@@ -94,12 +94,18 @@ export type CodecTypesOf<T> = [T] extends [never]
  * Dispatch hint identifying the first-argument target of an operation.
  *
  * Used by ORM column helpers to decide whether an operation is reachable on a
- * field. Either names a concrete codec identity or a set of capability traits
- * that the field's codec must carry.
+ * field. Either names a concrete codec identity, a set of capability traits
+ * that the field's codec must carry, or `any: true` meaning the operation
+ * applies to every codec irrespective of traits.
+ *
+ * Keep arms in lock-step with `SelfSpec` in `@prisma-next/operations` (same
+ * arms, same order). The runtime registry validates the same exactly-one-set
+ * invariant the type-level discriminated union encodes.
  */
 export type QueryOperationSelfSpec =
-  | { readonly codecId: string; readonly traits?: never }
-  | { readonly traits: readonly CodecTrait[]; readonly codecId?: never };
+  | { readonly codecId: string; readonly traits?: never; readonly any?: never }
+  | { readonly traits: readonly CodecTrait[]; readonly codecId?: never; readonly any?: never }
+  | { readonly any: true; readonly codecId?: never; readonly traits?: never };
 
 /**
  * Structural shape an operation's impl must return: any value carrying a