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

package/test/sql-context.test.ts

@@ -1,103 +1,40 @@
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-import type { SqlOperationSignature } from '@prisma-next/sql-operations';
-import type { CodecRegistry, SelectAst } from '@prisma-next/sql-relational-core/ast';
+import { type Contract, coreHash, executionHash, profileHash } from '@prisma-next/contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
 import { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import { describe, expect, it } from 'vitest';
 import {
-  createRuntimeContext,
+  createExecutionContext,
+  type SqlExecutionStack,
   type SqlRuntimeExtensionDescriptor,
-  type SqlRuntimeExtensionInstance,
+  type SqlRuntimeTargetDescriptor,
 } from '../src/sql-context';
+import {
+  createStubAdapter,
+  createTestAdapterDescriptor,
+  createTestTargetDescriptor,
+} from './utils';
 
-// Minimal test contract
-const testContract: SqlContract<SqlStorage> = {
-  schemaVersion: '1',
+const testContract: Contract<SqlStorage> = {
   targetFamily: 'sql',
   target: 'postgres',
-  coreHash: 'sha256:test',
+  profileHash: profileHash('sha256:test'),
   models: {},
-  relations: {},
-  storage: { tables: {} },
+  roots: {},
+  storage: { storageHash: coreHash('sha256:test'), tables: {} },
   extensionPacks: {},
   capabilities: {},
   meta: {},
-  sources: {},
-  mappings: {
-    codecTypes: {},
-    operationTypes: {},
-  },
 };
 
-// Stub adapter codecs
-function createStubCodecs(): CodecRegistry {
-  const registry = createCodecRegistry();
-  registry.register(
-    codec({
-      typeId: 'pg/int4@1',
-      targetTypes: ['int4'],
-      encode: (v: number) => v,
-      decode: (w: number) => w,
-    }),
-  );
-  return registry;
-}
-
-// Create a test adapter descriptor
-function createTestAdapterDescriptor() {
-  const codecs = createStubCodecs();
-  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: [] }),
-          };
-        },
-      };
-    },
-  };
-}
-
-// Create a test target descriptor
-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 };
-    },
-  };
-}
-
-// Create a test extension descriptor
 function createTestExtensionDescriptor(options?: {
   hasCodecs?: boolean;
   hasOperations?: boolean;
 }): SqlRuntimeExtensionDescriptor<'postgres'> {
   const { hasCodecs = false, hasOperations = false } = options ?? {};
 
-  // Build the codecs function if needed
-  const codecsFn = hasCodecs
-    ? () => {
+  const codecRegistry = hasCodecs
+    ? (() => {
         const registry = createCodecRegistry();
         registry.register(
           codec({
@@ -108,21 +45,23 @@ function createTestExtensionDescriptor(options?: {
           }),
         );
         return registry;
-      }
-    : undefined;
+      })()
+    : createCodecRegistry();
 
-  // Build the operations function if needed
-  const operationsFn = hasOperations
-    ? (): ReadonlyArray<SqlOperationSignature> => [
+  const operationsArray: ReadonlyArray<SqlOperationDescriptor> = hasOperations
+    ? [
         {
-          forTypeId: 'test/ext@1',
           method: 'testOp',
-          args: [],
-          returns: { kind: 'builtin', type: 'number' },
-          lowering: { targetFamily: 'sql', strategy: 'function', template: 'test()' },
+          args: [{ codecId: 'test/ext@1', nullable: false }],
+          returns: { codecId: 'test/ext@1', nullable: false },
+          lowering: {
+            targetFamily: 'sql' as const,
+            strategy: 'function' as const,
+            template: 'test()',
+          },
         },
       ]
-    : undefined;
+    : [];
 
   return {
     kind: 'extension' as const,
@@ -130,88 +69,316 @@ function createTestExtensionDescriptor(options?: {
     version: '0.0.1',
     familyId: 'sql' as const,
     targetId: 'postgres' as const,
-    create(): SqlRuntimeExtensionInstance<'postgres'> {
-      // Return object with optional methods only if they exist
-      const instance: SqlRuntimeExtensionInstance<'postgres'> = {
+    codecs: () => codecRegistry,
+    queryOperations: () => operationsArray,
+    parameterizedCodecs: () => [],
+    create() {
+      return {
         familyId: 'sql' as const,
         targetId: 'postgres' as const,
       };
-      if (codecsFn) {
-        (instance as { codecs?: () => CodecRegistry }).codecs = codecsFn;
-      }
-      if (operationsFn) {
-        (instance as { operations?: () => ReadonlyArray<SqlOperationSignature> }).operations =
-          operationsFn;
-      }
-      return instance;
     },
   };
 }
 
-describe('createRuntimeContext', () => {
-  it('creates context with adapter codecs', () => {
-    const context = createRuntimeContext({
+function createStack(options?: {
+  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;
+}): SqlExecutionStack<'postgres'> {
+  return {
+    target: createTestTargetDescriptor(),
+    adapter: createTestAdapterDescriptor(createStubAdapter()),
+    extensionPacks: options?.extensionPacks ?? [],
+  };
+}
+
+describe('createExecutionContext', () => {
+  it('creates context with adapter codecs from descriptor', () => {
+    const context = createExecutionContext({
       contract: testContract,
-      target: createTestTargetDescriptor(),
-      adapter: createTestAdapterDescriptor(),
+      stack: createStack(),
     });
 
     expect(context.contract).toBe(testContract);
-    expect(context.adapter).toBeDefined();
     expect(context.codecs.has('pg/int4@1')).toBe(true);
-    expect(context.operations).toBeDefined();
+    expect(context.queryOperations).toBeDefined();
   });
 
   it('creates context with empty extension packs', () => {
-    const context = createRuntimeContext({
+    const context = createExecutionContext({
       contract: testContract,
-      target: createTestTargetDescriptor(),
-      adapter: createTestAdapterDescriptor(),
-      extensionPacks: [],
+      stack: createStack({ extensionPacks: [] }),
     });
 
     expect(context.codecs.has('pg/int4@1')).toBe(true);
-    // No extension codecs registered
     expect(context.codecs.has('test/ext@1')).toBe(false);
   });
 
-  it('registers extension codecs', () => {
-    const context = createRuntimeContext({
+  it('registers extension codecs from descriptors', () => {
+    const context = createExecutionContext({
       contract: testContract,
-      target: createTestTargetDescriptor(),
-      adapter: createTestAdapterDescriptor(),
-      extensionPacks: [createTestExtensionDescriptor({ hasCodecs: true })],
+      stack: createStack({
+        extensionPacks: [createTestExtensionDescriptor({ hasCodecs: true })],
+      }),
     });
 
-    // Adapter codec
     expect(context.codecs.has('pg/int4@1')).toBe(true);
-    // Extension codec
     expect(context.codecs.has('test/ext@1')).toBe(true);
   });
 
-  it('registers extension operations', () => {
-    const context = createRuntimeContext({
+  it('registers extension operations from descriptors', () => {
+    const context = createExecutionContext({
       contract: testContract,
-      target: createTestTargetDescriptor(),
-      adapter: createTestAdapterDescriptor(),
-      extensionPacks: [createTestExtensionDescriptor({ hasOperations: true })],
+      stack: createStack({
+        extensionPacks: [createTestExtensionDescriptor({ hasOperations: true })],
+      }),
     });
 
-    const ops = context.operations.byType('test/ext@1');
-    expect(ops.length).toBe(1);
-    expect(ops[0]?.method).toBe('testOp');
+    const entries = context.queryOperations.entries();
+    expect(entries['testOp']).toBeDefined();
   });
 
-  it('handles extension without codecs or operations', () => {
-    const context = createRuntimeContext({
+  it('handles extension with no contributions', () => {
+    const context = createExecutionContext({
       contract: testContract,
-      target: createTestTargetDescriptor(),
-      adapter: createTestAdapterDescriptor(),
-      extensionPacks: [createTestExtensionDescriptor({ hasCodecs: false, hasOperations: false })],
+      stack: createStack({
+        extensionPacks: [createTestExtensionDescriptor({ hasCodecs: false, hasOperations: false })],
+      }),
     });
 
-    // Only adapter codec
     expect(context.codecs.has('pg/int4@1')).toBe(true);
     expect(context.codecs.has('test/ext@1')).toBe(false);
   });
 });
+
+describe('comprehensive descriptor-based derivation', () => {
+  it('includes all expected codec IDs and operations from target, adapter, and extensions', () => {
+    const targetCodecRegistry = createCodecRegistry();
+    targetCodecRegistry.register(
+      codec({
+        typeId: 'target/special@1',
+        targetTypes: ['special'],
+        encode: (v: string) => v,
+        decode: (w: string) => w,
+      }),
+    );
+
+    const targetOps: SqlOperationDescriptor[] = [
+      {
+        method: 'targetOp',
+        args: [{ codecId: 'target/special@1', nullable: false }],
+        returns: { codecId: 'target/special@1', nullable: false },
+        lowering: {
+          targetFamily: 'sql' as const,
+          strategy: 'function' as const,
+          template: 'target_fn()',
+        },
+      },
+    ];
+
+    const target: SqlRuntimeTargetDescriptor<'postgres'> = {
+      kind: 'target' as const,
+      id: 'postgres',
+      version: '0.0.1',
+      familyId: 'sql' as const,
+      targetId: 'postgres' as const,
+      codecs: () => targetCodecRegistry,
+      queryOperations: () => targetOps,
+      parameterizedCodecs: () => [],
+      create() {
+        return { familyId: 'sql' as const, targetId: 'postgres' as const };
+      },
+    };
+
+    const stack: SqlExecutionStack<'postgres'> = {
+      target,
+      adapter: createTestAdapterDescriptor(createStubAdapter()),
+      extensionPacks: [createTestExtensionDescriptor({ hasCodecs: true, hasOperations: true })],
+    };
+
+    const context = createExecutionContext({ contract: testContract, stack });
+
+    expect(context.codecs.has('target/special@1')).toBe(true);
+    expect(context.codecs.has('pg/int4@1')).toBe(true);
+    expect(context.codecs.has('test/ext@1')).toBe(true);
+
+    const entries = context.queryOperations.entries();
+    expect(entries['targetOp']).toBeDefined();
+    expect(entries['testOp']).toBeDefined();
+  });
+});
+
+describe('context.types presence', () => {
+  it('exists as empty object when no parameterized codecs are registered', () => {
+    const context = createExecutionContext({
+      contract: testContract,
+      stack: createStack(),
+    });
+
+    expect(context.types).toBeDefined();
+    expect(context.types).toEqual({});
+  });
+});
+
+describe('contract/stack validation errors', () => {
+  it('throws RUNTIME.CONTRACT_FAMILY_MISMATCH when contract targetFamily differs from stack', () => {
+    const mismatchedFamilyContract = {
+      ...testContract,
+      targetFamily: 'document',
+    } as unknown as Contract<SqlStorage>;
+
+    expect(() =>
+      createExecutionContext({ contract: mismatchedFamilyContract, stack: createStack() }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.CONTRACT_FAMILY_MISMATCH',
+        category: 'RUNTIME',
+        severity: 'error',
+        details: {
+          actual: 'document',
+          expected: 'sql',
+        },
+      }),
+    );
+  });
+
+  it('throws RUNTIME.CONTRACT_TARGET_MISMATCH when contract target differs from stack', () => {
+    const mismatchedContract: Contract<SqlStorage> = {
+      ...testContract,
+      target: 'mysql',
+    };
+
+    expect(() =>
+      createExecutionContext({ contract: mismatchedContract, stack: createStack() }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.CONTRACT_TARGET_MISMATCH',
+        category: 'RUNTIME',
+        severity: 'error',
+        details: {
+          actual: 'mysql',
+          expected: 'postgres',
+        },
+      }),
+    );
+  });
+
+  it('throws RUNTIME.MISSING_EXTENSION_PACK when contract requires extension not in stack', () => {
+    const contractWithExtension: Contract<SqlStorage> = {
+      ...testContract,
+      extensionPacks: {
+        'required-extension': { id: 'required-extension', version: '1.0.0', capabilities: {} },
+      },
+    };
+
+    expect(() =>
+      createExecutionContext({ contract: contractWithExtension, stack: createStack() }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.MISSING_EXTENSION_PACK',
+        category: 'RUNTIME',
+        severity: 'error',
+        details: {
+          packIds: ['required-extension'],
+        },
+      }),
+    );
+  });
+
+  it('lists all missing extension packs in a single error', () => {
+    const contractWithExtensions: Contract<SqlStorage> = {
+      ...testContract,
+      extensionPacks: {
+        'ext-a': { id: 'ext-a', version: '1.0.0', capabilities: {} },
+        'ext-b': { id: 'ext-b', version: '1.0.0', capabilities: {} },
+      },
+    };
+
+    expect(() =>
+      createExecutionContext({ contract: contractWithExtensions, stack: createStack() }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.MISSING_EXTENSION_PACK',
+        details: {
+          packIds: expect.arrayContaining(['ext-a', 'ext-b']),
+        },
+      }),
+    );
+  });
+});
+
+describe('applyMutationDefaults', () => {
+  const contractWithDefaults: Contract<SqlStorage> = {
+    ...testContract,
+    storage: {
+      storageHash: coreHash('sha256:test'),
+      tables: {
+        user: {
+          columns: {
+            id: { nativeType: 'text', codecId: 'pg/text@1', nullable: false },
+            slug: { nativeType: 'text', codecId: 'pg/text@1', nullable: false },
+          },
+          uniques: [],
+          indexes: [],
+          foreignKeys: [],
+        },
+      },
+    },
+    execution: {
+      executionHash: executionHash('sha256:test'),
+      mutations: {
+        defaults: [
+          {
+            ref: { table: 'user', column: 'id' },
+            onCreate: { kind: 'generator', id: 'nanoid', params: { size: 8 } },
+          },
+          {
+            ref: { table: 'user', column: 'slug' },
+            onUpdate: { kind: 'generator', id: 'nanoid', params: { size: 6 } },
+          },
+        ],
+      },
+    },
+  };
+
+  it('applies create defaults with generator params', () => {
+    const context = createExecutionContext({
+      contract: contractWithDefaults,
+      stack: createStack(),
+    });
+
+    const applied = context.applyMutationDefaults({
+      op: 'create',
+      table: 'user',
+      values: {},
+    });
+
+    expect(applied).toEqual([
+      {
+        column: 'id',
+        value: expect.any(String),
+      },
+    ]);
+    expect((applied[0]?.value as string).length).toBe(8);
+  });
+
+  it('applies update defaults from onUpdate', () => {
+    const context = createExecutionContext({
+      contract: contractWithDefaults,
+      stack: createStack(),
+    });
+
+    const applied = context.applyMutationDefaults({
+      op: 'update',
+      table: 'user',
+      values: {},
+    });
+
+    expect(applied).toEqual([
+      {
+        column: 'slug',
+        value: expect.any(String),
+      },
+    ]);
+    expect((applied[0]?.value as string).length).toBe(6);
+  });
+});

package/test/sql-family-adapter.test.ts

@@ -1,42 +1,59 @@
-import type { ExecutionPlan } from '@prisma-next/contract/types';
-import type { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
+import type { Contract, ExecutionPlan } from '@prisma-next/contract/types';
+import { coreHash, profileHash } from '@prisma-next/contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import type { AdapterProfile } from '@prisma-next/sql-relational-core/ast';
 import { describe, expect, it } from 'vitest';
 import { SqlFamilyAdapter } from '../src/sql-family-adapter';
 
 // Minimal test contract
-const testContract: SqlContract<SqlStorage> = {
-  schemaVersion: '1',
+const testContract: Contract<SqlStorage> = {
   targetFamily: 'sql',
   target: 'postgres',
-  coreHash: 'sha256:test-hash',
+  profileHash: profileHash('sha256:test-hash'),
   models: {},
-  relations: {},
-  storage: { tables: {} },
+  roots: {},
+  storage: { storageHash: coreHash('sha256:test-hash'), tables: {} },
   extensionPacks: {},
   capabilities: {},
   meta: {},
-  sources: {},
-  mappings: {
-    codecTypes: {},
-    operationTypes: {},
+};
+
+const testProfile: AdapterProfile = {
+  id: 'test/default@1',
+  target: 'postgres',
+  capabilities: {},
+  codecs: () => {
+    throw new Error('not needed in test');
   },
+  readMarkerStatement: () => ({
+    sql: 'SELECT core_hash, profile_hash FROM prisma_contract.marker WHERE id = $1',
+    params: [1],
+  }),
 };
 
 describe('SqlFamilyAdapter', () => {
   it('creates adapter with contract and marker reader', () => {
-    const adapter = new SqlFamilyAdapter(testContract);
+    const adapter = new SqlFamilyAdapter(testContract, testProfile);
 
     expect(adapter.contract).toBe(testContract);
     expect(adapter.markerReader).toBeDefined();
     expect(adapter.markerReader.readMarkerStatement).toBeDefined();
   });
 
+  it('delegates readMarkerStatement to adapter profile', () => {
+    const adapter = new SqlFamilyAdapter(testContract, testProfile);
+    const stmt = adapter.markerReader.readMarkerStatement();
+
+    expect(stmt.sql).toContain('prisma_contract.marker');
+    expect(stmt.params).toEqual([1]);
+  });
+
   it('validates plan with matching target and hash', () => {
-    const adapter = new SqlFamilyAdapter(testContract);
+    const adapter = new SqlFamilyAdapter(testContract, testProfile);
     const plan: ExecutionPlan = {
       meta: {
         target: 'postgres',
-        coreHash: 'sha256:test-hash',
+        storageHash: 'sha256:test-hash',
         lane: 'sql',
         paramDescriptors: [],
       },
@@ -49,11 +66,11 @@ describe('SqlFamilyAdapter', () => {
   });
 
   it('throws on plan target mismatch', () => {
-    const adapter = new SqlFamilyAdapter(testContract);
+    const adapter = new SqlFamilyAdapter(testContract, testProfile);
     const plan: ExecutionPlan = {
       meta: {
         target: 'mysql', // Wrong target
-        coreHash: 'sha256:test-hash',
+        storageHash: 'sha256:test-hash',
         lane: 'sql',
         paramDescriptors: [],
       },
@@ -66,12 +83,12 @@ describe('SqlFamilyAdapter', () => {
     );
   });
 
-  it('throws on plan coreHash mismatch', () => {
-    const adapter = new SqlFamilyAdapter(testContract);
+  it('throws on plan storageHash mismatch', () => {
+    const adapter = new SqlFamilyAdapter(testContract, testProfile);
     const plan: ExecutionPlan = {
       meta: {
         target: 'postgres',
-        coreHash: 'sha256:different-hash', // Wrong hash
+        storageHash: 'sha256:different-hash', // Wrong hash
         lane: 'sql',
         paramDescriptors: [],
       },
@@ -80,7 +97,7 @@ describe('SqlFamilyAdapter', () => {
     };
 
     expect(() => adapter.validatePlan(plan, testContract)).toThrow(
-      'Plan core hash does not match runtime contract',
+      'Plan storage hash does not match runtime contract',
     );
   });
 });