@prisma-next/sql-runtime 0.3.0-pr.99.6 → 0.3.0

package/test/parameterized-types.test.ts

@@ -1,21 +1,22 @@
-import type { SqlContract, SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
-import type { SelectAst } from '@prisma-next/sql-relational-core/ast';
+import type { Contract } from '@prisma-next/contract/types';
+import { coreHash, profileHash } from '@prisma-next/contract/types';
+import type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import { ifDefined } from '@prisma-next/utils/defined';
 import type { Type } from 'arktype';
 import { type as arktype } from 'arktype';
 import { describe, expect, it } from 'vitest';
-import {
-  createRuntimeContext,
-  type RuntimeParameterizedCodecDescriptor,
-  type SqlRuntimeExtensionDescriptor,
-  type SqlRuntimeExtensionInstance,
+import type {
+  RuntimeParameterizedCodecDescriptor,
+  SqlRuntimeExtensionDescriptor,
 } from '../src/sql-context';
+import { createStubAdapter, createTestContext } from './utils';
 
 // =============================================================================
 // Test helpers
 // =============================================================================
 
-function createTestContract(
+function createParamTypesTestContract(
   options?: Partial<{
     types: Record<string, StorageTypeInstance>;
     tableColumns: Record<
@@ -29,15 +30,15 @@ function createTestContract(
       }
     >;
   }>,
-): SqlContract<SqlStorage> {
+): Contract<SqlStorage> {
   return {
-    schemaVersion: '1',
     targetFamily: 'sql',
     target: 'postgres',
-    coreHash: 'sha256:test',
+    profileHash: profileHash('sha256:test'),
     models: {},
-    relations: {},
+    roots: {},
     storage: {
+      storageHash: coreHash('sha256:test'),
       tables: {
         test: {
           columns: options?.tableColumns ?? {
@@ -49,69 +50,11 @@ function createTestContract(
           foreignKeys: [],
         },
       },
-      ...(options?.types ? { types: options.types } : {}),
+      ...ifDefined('types', options?.types),
     },
     extensionPacks: {},
     capabilities: {},
     meta: {},
-    sources: {},
-    mappings: {
-      codecTypes: {},
-      operationTypes: {},
-    },
-  };
-}
-
-function createTestAdapterDescriptor() {
-  const codecs = createCodecRegistry();
-  codecs.register(
-    codec({
-      typeId: 'pg/int4@1',
-      targetTypes: ['int4'],
-      encode: (v: number) => v,
-      decode: (w: number) => w,
-    }),
-  );
-
-  return {
-    kind: 'adapter' as const,
-    id: 'test-adapter',
-    version: '0.0.1',
-    familyId: 'sql' as const,
-    targetId: 'postgres' as const,
-    create() {
-      return {
-        familyId: 'sql' as const,
-        targetId: 'postgres' as const,
-        profile: {
-          id: 'test-profile',
-          target: 'postgres',
-          capabilities: {},
-          codecs() {
-            return codecs;
-          },
-        },
-        lower(ast: SelectAst) {
-          return {
-            profileId: 'test-profile',
-            body: Object.freeze({ sql: JSON.stringify(ast), params: [] }),
-          };
-        },
-      };
-    },
-  };
-}
-
-function createTestTargetDescriptor() {
-  return {
-    kind: 'target' as const,
-    id: 'postgres',
-    version: '0.0.1',
-    familyId: 'sql' as const,
-    targetId: 'postgres' as const,
-    create() {
-      return { familyId: 'sql' as const, targetId: 'postgres' as const };
-    },
   };
 }
 
@@ -122,19 +65,15 @@ function createTestTargetDescriptor() {
 describe('parameterized types', () => {
   describe('storage.types validation', () => {
     it('creates context with empty storage.types', () => {
-      const contract = createTestContract({ types: {} });
-      const context = createRuntimeContext({
-        contract,
-        target: createTestTargetDescriptor(),
-        adapter: createTestAdapterDescriptor(),
-      });
+      const contract = createParamTypesTestContract({ types: {} });
+      const context = createTestContext(contract, createStubAdapter());
 
       expect(context.contract.storage.types).toEqual({});
       expect(context.types).toEqual({});
     });
 
     it('creates context with storage.types containing valid type instances', () => {
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         types: {
           Vector1536: {
             codecId: 'pg/vector@1',
@@ -143,11 +82,7 @@ describe('parameterized types', () => {
           },
         },
       });
-      const context = createRuntimeContext({
-        contract,
-        target: createTestTargetDescriptor(),
-        adapter: createTestAdapterDescriptor(),
-      });
+      const context = createTestContext(contract, createStubAdapter());
 
       expect(context.contract.storage.types).toEqual({
         Vector1536: {
@@ -157,7 +92,7 @@ describe('parameterized types', () => {
         },
       });
       // types registry should contain the raw type instance (no init hook provided)
-      expect(context.types?.['Vector1536']).toBeDefined();
+      expect(context.types['Vector1536']).toBeDefined();
     });
   });
 
@@ -175,38 +110,39 @@ describe('parameterized types', () => {
         {
           codecId: 'pg/vector@1',
           paramsSchema: options?.paramsSchema ?? vectorParamsSchema,
-          ...(options?.init ? { init: options.init } : {}),
+          ...ifDefined('init', options?.init),
         },
       ];
 
+      const registry = createCodecRegistry();
+      registry.register(
+        codec({
+          typeId: 'pg/vector@1',
+          targetTypes: ['vector'],
+          encode: (v: number[]) => v,
+          decode: (w: number[]) => w,
+        }),
+      );
+
       return {
         kind: 'extension' as const,
         id: 'pgvector',
         version: '0.0.1',
         familyId: 'sql' as const,
         targetId: 'postgres' as const,
-        create(): SqlRuntimeExtensionInstance<'postgres'> {
-          const registry = createCodecRegistry();
-          registry.register(
-            codec({
-              typeId: 'pg/vector@1',
-              targetTypes: ['vector'],
-              encode: (v: number[]) => v,
-              decode: (w: number[]) => w,
-            }),
-          );
+        codecs: () => registry,
+        parameterizedCodecs: () => parameterizedCodecs,
+        create() {
           return {
             familyId: 'sql' as const,
             targetId: 'postgres' as const,
-            codecs: () => registry,
-            parameterizedCodecs: () => parameterizedCodecs,
           };
         },
       };
     }
 
     it('validates typeParams against codec paramsSchema', () => {
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         types: {
           Vector1536: {
             codecId: 'pg/vector@1',
@@ -216,18 +152,15 @@ describe('parameterized types', () => {
         },
       });
 
-      const context = createRuntimeContext({
-        contract,
-        target: createTestTargetDescriptor(),
-        adapter: createTestAdapterDescriptor(),
+      const context = createTestContext(contract, createStubAdapter(), {
         extensionPacks: [createVectorExtensionDescriptor()],
       });
 
-      expect(context.types?.['Vector1536']).toBeDefined();
+      expect(context.types['Vector1536']).toBeDefined();
     });
 
     it('rejects invalid typeParams with stable error code', () => {
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         types: {
           InvalidVector: {
             codecId: 'pg/vector@1',
@@ -239,10 +172,7 @@ describe('parameterized types', () => {
 
       let thrownError: unknown;
       try {
-        createRuntimeContext({
-          contract,
-          target: createTestTargetDescriptor(),
-          adapter: createTestAdapterDescriptor(),
+        createTestContext(contract, createStubAdapter(), {
           extensionPacks: [createVectorExtensionDescriptor()],
         });
       } catch (e) {
@@ -262,7 +192,7 @@ describe('parameterized types', () => {
     });
 
     it('rejects missing required typeParams with stable error code', () => {
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         types: {
           InvalidVector: {
             codecId: 'pg/vector@1',
@@ -274,10 +204,7 @@ describe('parameterized types', () => {
 
       let thrownError: unknown;
       try {
-        createRuntimeContext({
-          contract,
-          target: createTestTargetDescriptor(),
-          adapter: createTestAdapterDescriptor(),
+        createTestContext(contract, createStubAdapter(), {
           extensionPacks: [createVectorExtensionDescriptor()],
         });
       } catch (e) {
@@ -304,38 +231,41 @@ describe('parameterized types', () => {
         isVector: true,
       });
 
+      const registry = createCodecRegistry();
+      registry.register(
+        codec({
+          typeId: 'pg/vector@1',
+          targetTypes: ['vector'],
+          encode: (v: number[]) => v,
+          decode: (w: number[]) => w,
+        }),
+      );
+
+      const parameterizedCodecs = [
+        {
+          codecId: 'pg/vector@1',
+          paramsSchema: vectorParamsSchema,
+          init: initFn,
+        },
+      ];
+
       const extensionDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
         kind: 'extension' as const,
         id: 'pgvector',
         version: '0.0.1',
         familyId: 'sql' as const,
         targetId: 'postgres' as const,
-        create(): SqlRuntimeExtensionInstance<'postgres'> {
-          const registry = createCodecRegistry();
-          registry.register(
-            codec({
-              typeId: 'pg/vector@1',
-              targetTypes: ['vector'],
-              encode: (v: number[]) => v,
-              decode: (w: number[]) => w,
-            }),
-          );
+        codecs: () => registry,
+        parameterizedCodecs: () => parameterizedCodecs,
+        create() {
           return {
             familyId: 'sql' as const,
             targetId: 'postgres' as const,
-            codecs: () => registry,
-            parameterizedCodecs: () => [
-              {
-                codecId: 'pg/vector@1',
-                paramsSchema: vectorParamsSchema,
-                init: initFn,
-              },
-            ],
           };
         },
       };
 
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         types: {
           Vector1536: {
             codecId: 'pg/vector@1',
@@ -345,14 +275,11 @@ describe('parameterized types', () => {
         },
       });
 
-      const context = createRuntimeContext({
-        contract,
-        target: createTestTargetDescriptor(),
-        adapter: createTestAdapterDescriptor(),
+      const context = createTestContext(contract, createStubAdapter(), {
         extensionPacks: [extensionDescriptor],
       });
 
-      expect(context.types?.['Vector1536']).toEqual({
+      expect(context.types['Vector1536']).toEqual({
         dimensions: 1536,
         isVector: true,
       });
@@ -363,38 +290,40 @@ describe('parameterized types', () => {
         length: 'number',
       });
 
+      const registry = createCodecRegistry();
+      registry.register(
+        codec({
+          typeId: 'pg/vector@1',
+          targetTypes: ['vector'],
+          encode: (v: number[]) => v,
+          decode: (w: number[]) => w,
+        }),
+      );
+
+      const parameterizedCodecs = [
+        {
+          codecId: 'pg/vector@1',
+          paramsSchema: vectorParamsSchema,
+        },
+      ];
+
       const extensionDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
         kind: 'extension' as const,
         id: 'pgvector',
         version: '0.0.1',
         familyId: 'sql' as const,
         targetId: 'postgres' as const,
-        create(): SqlRuntimeExtensionInstance<'postgres'> {
-          const registry = createCodecRegistry();
-          registry.register(
-            codec({
-              typeId: 'pg/vector@1',
-              targetTypes: ['vector'],
-              encode: (v: number[]) => v,
-              decode: (w: number[]) => w,
-            }),
-          );
+        codecs: () => registry,
+        parameterizedCodecs: () => parameterizedCodecs,
+        create() {
           return {
             familyId: 'sql' as const,
             targetId: 'postgres' as const,
-            codecs: () => registry,
-            parameterizedCodecs: () => [
-              {
-                codecId: 'pg/vector@1',
-                paramsSchema: vectorParamsSchema,
-                // No init hook
-              },
-            ],
           };
         },
       };
 
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         types: {
           Vector1536: {
             codecId: 'pg/vector@1',
@@ -404,15 +333,12 @@ describe('parameterized types', () => {
         },
       });
 
-      const context = createRuntimeContext({
-        contract,
-        target: createTestTargetDescriptor(),
-        adapter: createTestAdapterDescriptor(),
+      const context = createTestContext(contract, createStubAdapter(), {
         extensionPacks: [extensionDescriptor],
       });
 
       // Without init hook, stores the full type instance (matches contract typing)
-      expect(context.types?.['Vector1536']).toEqual({
+      expect(context.types['Vector1536']).toEqual({
         codecId: 'pg/vector@1',
         nativeType: 'vector',
         typeParams: { length: 1536 },
@@ -426,37 +352,40 @@ describe('parameterized types', () => {
         length: 'number',
       });
 
+      const registry = createCodecRegistry();
+      registry.register(
+        codec({
+          typeId: 'pg/vector@1',
+          targetTypes: ['vector'],
+          encode: (v: number[]) => v,
+          decode: (w: number[]) => w,
+        }),
+      );
+
+      const parameterizedCodecs = [
+        {
+          codecId: 'pg/vector@1',
+          paramsSchema: vectorParamsSchema,
+        },
+      ];
+
       const extensionDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
         kind: 'extension' as const,
         id: 'pgvector',
         version: '0.0.1',
         familyId: 'sql' as const,
         targetId: 'postgres' as const,
-        create(): SqlRuntimeExtensionInstance<'postgres'> {
-          const registry = createCodecRegistry();
-          registry.register(
-            codec({
-              typeId: 'pg/vector@1',
-              targetTypes: ['vector'],
-              encode: (v: number[]) => v,
-              decode: (w: number[]) => w,
-            }),
-          );
+        codecs: () => registry,
+        parameterizedCodecs: () => parameterizedCodecs,
+        create() {
           return {
             familyId: 'sql' as const,
             targetId: 'postgres' as const,
-            codecs: () => registry,
-            parameterizedCodecs: () => [
-              {
-                codecId: 'pg/vector@1',
-                paramsSchema: vectorParamsSchema,
-              },
-            ],
           };
         },
       };
 
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         tableColumns: {
           id: { nativeType: 'int4', codecId: 'pg/int4@1', nullable: false },
           embedding: {
@@ -469,10 +398,7 @@ describe('parameterized types', () => {
       });
 
       // Should not throw - valid typeParams
-      const context = createRuntimeContext({
-        contract,
-        target: createTestTargetDescriptor(),
-        adapter: createTestAdapterDescriptor(),
+      const context = createTestContext(contract, createStubAdapter(), {
         extensionPacks: [extensionDescriptor],
       });
 
@@ -484,37 +410,40 @@ describe('parameterized types', () => {
         length: 'number',
       });
 
+      const registry = createCodecRegistry();
+      registry.register(
+        codec({
+          typeId: 'pg/vector@1',
+          targetTypes: ['vector'],
+          encode: (v: number[]) => v,
+          decode: (w: number[]) => w,
+        }),
+      );
+
+      const parameterizedCodecs = [
+        {
+          codecId: 'pg/vector@1',
+          paramsSchema: vectorParamsSchema,
+        },
+      ];
+
       const extensionDescriptor: SqlRuntimeExtensionDescriptor<'postgres'> = {
         kind: 'extension' as const,
         id: 'pgvector',
         version: '0.0.1',
         familyId: 'sql' as const,
         targetId: 'postgres' as const,
-        create(): SqlRuntimeExtensionInstance<'postgres'> {
-          const registry = createCodecRegistry();
-          registry.register(
-            codec({
-              typeId: 'pg/vector@1',
-              targetTypes: ['vector'],
-              encode: (v: number[]) => v,
-              decode: (w: number[]) => w,
-            }),
-          );
+        codecs: () => registry,
+        parameterizedCodecs: () => parameterizedCodecs,
+        create() {
           return {
             familyId: 'sql' as const,
             targetId: 'postgres' as const,
-            codecs: () => registry,
-            parameterizedCodecs: () => [
-              {
-                codecId: 'pg/vector@1',
-                paramsSchema: vectorParamsSchema,
-              },
-            ],
           };
         },
       };
 
-      const contract = createTestContract({
+      const contract = createParamTypesTestContract({
         tableColumns: {
           id: { nativeType: 'int4', codecId: 'pg/int4@1', nullable: false },
           embedding: {
@@ -528,10 +457,7 @@ describe('parameterized types', () => {
 
       let thrownError: unknown;
       try {
-        createRuntimeContext({
-          contract,
-          target: createTestTargetDescriptor(),
-          adapter: createTestAdapterDescriptor(),
+        createTestContext(contract, createStubAdapter(), {
           extensionPacks: [extensionDescriptor],
         });
       } catch (e) {
@@ -550,4 +476,54 @@ describe('parameterized types', () => {
       });
     });
   });
+
+  describe('duplicate codec descriptor detection', () => {
+    it('throws RUNTIME.DUPLICATE_PARAMETERIZED_CODEC when multiple extensions provide same codecId', () => {
+      const vectorParamsSchema = arktype({
+        length: 'number',
+      });
+
+      function createVectorExtension(id: string): SqlRuntimeExtensionDescriptor<'postgres'> {
+        const parameterizedCodecs = [
+          {
+            codecId: 'pg/vector@1',
+            paramsSchema: vectorParamsSchema,
+          },
+        ];
+
+        return {
+          kind: 'extension' as const,
+          id,
+          version: '0.0.1',
+          familyId: 'sql' as const,
+          targetId: 'postgres' as const,
+          codecs: () => createCodecRegistry(),
+          parameterizedCodecs: () => parameterizedCodecs,
+          create() {
+            return {
+              familyId: 'sql' as const,
+              targetId: 'postgres' as const,
+            };
+          },
+        };
+      }
+
+      const contract = createParamTypesTestContract();
+
+      expect(() =>
+        createTestContext(contract, createStubAdapter(), {
+          extensionPacks: [createVectorExtension('ext-1'), createVectorExtension('ext-2')],
+        }),
+      ).toThrow(
+        expect.objectContaining({
+          code: 'RUNTIME.DUPLICATE_PARAMETERIZED_CODEC',
+          category: 'RUNTIME',
+          severity: 'error',
+          details: {
+            codecId: 'pg/vector@1',
+          },
+        }),
+      );
+    });
+  });
 });