prisma · jkomyno · May 8, 2026 · May 4, 2026 · May 4, 2026 · May 5, 2026
@@ -340,7 +340,11 @@ const plan = o.user()
 - **DML operations** via INSERT, UPDATE, DELETE statements with model-to-column mapping
 - **One call → one statement** remains the rule
 
-The ORM is optional and layered on top of the DSL.
+The ORM is optional and layered on top of the SQL DSL query-builder lane (`db.sql` / `sql()`).
+
+### Id-less tables and primary-key fallback
+
+`storage.tables.<t>.primaryKey` is optional in the SQL contract. Id-less SQL tables are emittable from PSL (`model X { ... }` without `@id`/`@@id`) and from introspection. This is not a general restriction on ORM collection operations: predicate-based reads and writes such as `where(...).first()`, `where(...).update(...)`, and `where(...).delete()` can target id-less tables because the caller provides the row-matching predicate explicitly. The SQL DSL query-builder lane (`db.sql` / `sql()`) is also safe for the same reason: callers state the table, predicates, and projection directly. The unsafe case is primary-key fallback behavior, such as mutation reloads, default upsert conflict columns, count helpers that currently select the primary-key column before mutating, or future `findUnique`-style APIs. Those helpers must either require an explicit unique predicate or be gated by a per-model capability.
 
 ### Shared Collection interface across families
 

@@ -17,7 +17,7 @@ import type { EmissionSpi } from '@prisma-next/framework-components/emission';
 import { timeouts } from '@prisma-next/test-utils';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { notOk, ok } from '@prisma-next/utils/result';
-import { describe, expect, it, vi } from 'vitest';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 vi.mock('@prisma-next/emitter', () => ({
   emit: vi.fn(
@@ -36,6 +36,20 @@ import type { ControlProgressEvent } from '../../src/control-api/types';
 
 const mockEmit = vi.mocked(emitFn);
 
+function createMockEmitResult(): EmitResult {
+  return {
+    storageHash: 'test-core-hash',
+    profileHash: 'test-profile-hash',
+    contractJson: '{"test": true}',
+    contractDts: 'export interface Contract {}',
+  };
+}
+
+beforeEach(() => {
+  mockEmit.mockReset();
+  mockEmit.mockResolvedValue(createMockEmitResult());
+});
+
 function createSourceProvider(
   load: ContractSourceProvider['load'] = async () => ok({ test: true } as unknown as Contract),
   inputs?: readonly string[],

@@ -10,6 +10,7 @@ export default defineConfig({
     pool: 'forks',
     maxWorkers: 1,
     isolate: false,
+    fileParallelism: false,
     testTimeout: timeouts.vitestPackageDefault,
     hookTimeout: timeouts.vitestPackageDefault,
     setupFiles: ['./test/setup.ts'],

@@ -171,70 +171,74 @@ describe('emitter round-trip', () => {
     timeouts.typeScriptCompilation,
   );
 
-  it('round-trip with nullable fields', async () => {
-    const ir = createTestContract({
-      storage: {
-        tables: {
-          user: {
-            columns: {
-              id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
-              email: { codecId: 'pg/text@1', nativeType: 'text', nullable: true },
-              name: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+  it(
+    'round-trip with nullable fields',
+    async () => {
+      const ir = createTestContract({
+        storage: {
+          tables: {
+            user: {
+              columns: {
+                id: { codecId: 'pg/int4@1', nativeType: 'int4', nullable: false },
+                email: { codecId: 'pg/text@1', nativeType: 'text', nullable: true },
+                name: { codecId: 'pg/text@1', nativeType: 'text', nullable: false },
+              },
+              primaryKey: { columns: ['id'] },
+              uniques: [],
+              indexes: [],
+              foreignKeys: [],
             },
-            primaryKey: { columns: ['id'] },
-            uniques: [],
-            indexes: [],
-            foreignKeys: [],
           },
         },
-      },
-      extensionPacks: {
-        postgres: { version: '0.0.1' },
-        pg: {},
-      },
-    });
+        extensionPacks: {
+          postgres: { version: '0.0.1' },
+          pg: {},
+        },
+      });
 
-    const codecTypeImports: TypesImportSpec[] = [];
-    const operationTypeImports: TypesImportSpec[] = [];
-    const extensionIds = ['postgres', 'pg'];
-    const options: EmitStackInput = {
-      codecTypeImports,
-      operationTypeImports,
-      extensionIds,
-    };
+      const codecTypeImports: TypesImportSpec[] = [];
+      const operationTypeImports: TypesImportSpec[] = [];
+      const extensionIds = ['postgres', 'pg'];
+      const options: EmitStackInput = {
+        codecTypeImports,
+        operationTypeImports,
+        extensionIds,
+      };
 
-    const result1 = await emit(ir, options, mockSqlHook);
-    const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
+      const result1 = await emit(ir, options, mockSqlHook);
+      const contractJson1 = JSON.parse(result1.contractJson) as Record<string, unknown>;
 
-    const ir2 = createTestContract({
-      targetFamily: contractJson1['targetFamily'] as string,
-      target: contractJson1['target'] as string,
-      roots: contractJson1['roots'] as Record<string, string>,
-      models: contractJson1['models'] as Record<string, unknown>,
-      storage: contractJson1['storage'] as Record<string, unknown>,
-      extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
-      capabilities:
-        (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
-      meta: (contractJson1['meta'] as Record<string, unknown>) || {},
-    });
+      const ir2 = createTestContract({
+        targetFamily: contractJson1['targetFamily'] as string,
+        target: contractJson1['target'] as string,
+        roots: contractJson1['roots'] as Record<string, string>,
+        models: contractJson1['models'] as Record<string, unknown>,
+        storage: contractJson1['storage'] as Record<string, unknown>,
+        extensionPacks: contractJson1['extensionPacks'] as Record<string, unknown>,
+        capabilities:
+          (contractJson1['capabilities'] as Record<string, Record<string, boolean>>) || {},
+        meta: (contractJson1['meta'] as Record<string, unknown>) || {},
+      });
 
-    const result2 = await emit(ir2, options, mockSqlHook);
+      const result2 = await emit(ir2, options, mockSqlHook);
 
-    expect(result1.contractJson).toBe(result2.contractJson);
-    expect(result1.storageHash).toBe(result2.storageHash);
+      expect(result1.contractJson).toBe(result2.contractJson);
+      expect(result1.storageHash).toBe(result2.storageHash);
 
-    const parsed2 = JSON.parse(result2.contractJson) as Record<string, unknown>;
-    const storage = parsed2['storage'] as Record<string, unknown>;
-    const tables = storage['tables'] as Record<string, unknown>;
-    const user = tables['user'] as Record<string, unknown>;
-    const columns = user['columns'] as Record<string, unknown>;
-    const id = columns['id'] as Record<string, unknown>;
-    const email = columns['email'] as Record<string, unknown>;
-    const name = columns['name'] as Record<string, unknown>;
-    expect(id['nullable']).toBe(false);
-    expect(email['nullable']).toBe(true);
-    expect(name['nullable']).toBe(false);
-  });
+      const parsed2 = JSON.parse(result2.contractJson) as Record<string, unknown>;
+      const storage = parsed2['storage'] as Record<string, unknown>;
+      const tables = storage['tables'] as Record<string, unknown>;
+      const user = tables['user'] as Record<string, unknown>;
+      const columns = user['columns'] as Record<string, unknown>;
+      const id = columns['id'] as Record<string, unknown>;
+      const email = columns['email'] as Record<string, unknown>;
+      const name = columns['name'] as Record<string, unknown>;
+      expect(id['nullable']).toBe(false);
+      expect(email['nullable']).toBe(true);
+      expect(name['nullable']).toBe(false);
+    },
+    timeouts.typeScriptCompilation,
+  );
 
   it('round-trip with capabilities', async () => {
     const ir = createTestContract({

@@ -124,6 +124,11 @@ export function prismaVitePlugin(
       log(`  → ${result.files.json}`, 'debug');
       log(`  → ${result.files.dts}`, 'debug');
 
+      if (server) {
+        server.moduleGraph.onFileChange(result.files.json);
+        server.moduleGraph.onFileChange(result.files.dts);
+      }
+
       if (server && !hasQueuedEmit) {
         server.ws.send({ type: 'full-reload' });
       } else if (hasQueuedEmit) {

@@ -135,6 +135,7 @@ function createMockServer() {
     ssrLoadModule: vi.fn().mockResolvedValue({}),
     moduleGraph: {
       getModuleById: vi.fn().mockReturnValue(null),
+      onFileChange: vi.fn(),
     },
   };
 }
@@ -415,6 +416,22 @@ describe('prismaVitePlugin', () => {
       );
     });
 
+    it('invalidates emitted artifacts after successful emit', async () => {
+      const plugin = prismaVitePlugin('prisma-next.config.ts', { logLevel: 'silent' });
+      const mockServer = createMockServer();
+
+      const configResolved = plugin.configResolved as unknown as (config: { root: string }) => void;
+      configResolved({ root: '/project' });
+
+      const configureServer = plugin.configureServer as unknown as (
+        server: ReturnType<typeof createMockServer>,
+      ) => Promise<void>;
+      await configureServer(mockServer);
+
+      expect(mockServer.moduleGraph.onFileChange).toHaveBeenCalledWith('/out/contract.json');
+      expect(mockServer.moduleGraph.onFileChange).toHaveBeenCalledWith('/out/contract.d.ts');
+    });
+
     it('loads config once on startup before the initial emit', async () => {
       const plugin = prismaVitePlugin('prisma-next.config.ts', { logLevel: 'silent' });
       const mockServer = createMockServer();

@@ -139,6 +139,17 @@ function isPlainRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
+function findDuplicateValue(values: readonly string[]): string | undefined {
+  const seen = new Set<string>();
+  for (const value of values) {
+    if (seen.has(value)) {
+      return value;
+    }
+    seen.add(value);
+  }
+  return undefined;
+}
+
 function isContractFieldType(value: unknown): boolean {
   if (!isPlainRecord(value)) return false;
   const kind = value['kind'];
@@ -293,6 +304,8 @@ export function validateSqlContract<T extends Contract<SqlStorage>>(value: unkno
  * Currently checks:
  * - duplicate named primary key / unique / index / foreign key objects within a table
  * - duplicate unique, index, or foreign key declarations within a table
+ * - duplicate columns within primary key / unique / index definitions
+ * - nullable columns in primary key definitions
  * - `setNull` referential action on a non-nullable FK column (would fail at runtime)
  * - `setDefault` referential action on a non-nullable FK column without a DEFAULT (would fail at runtime)
  */
@@ -325,8 +338,33 @@ export function validateStorageSemantics(storage: SqlStorage): string[] {
       }
     }
 
+    if (table.primaryKey) {
+      const duplicateColumn = findDuplicateValue(table.primaryKey.columns);
+      if (duplicateColumn !== undefined) {
+        errors.push(
+          `Table "${tableName}": primary key contains duplicate column "${duplicateColumn}"`,
+        );
+      }
+
+      for (const columnName of table.primaryKey.columns) {
+        const column = table.columns[columnName];
+        if (column?.nullable === true) {
+          errors.push(
+            `Table "${tableName}": primary key column "${columnName}" is nullable; primary key columns must be NOT NULL`,
+          );
+        }
+      }
+    }
+
     const seenUniqueDefinitions = new Set<string>();
     for (const unique of table.uniques) {
+      const duplicateColumn = findDuplicateValue(unique.columns);
+      if (duplicateColumn !== undefined) {
+        errors.push(
+          `Table "${tableName}": unique constraint contains duplicate column "${duplicateColumn}"`,
+        );
+      }
+
       const signature = JSON.stringify({ columns: unique.columns });
       if (seenUniqueDefinitions.has(signature)) {
         errors.push(
@@ -339,6 +377,11 @@ export function validateStorageSemantics(storage: SqlStorage): string[] {
 
     const seenIndexDefinitions = new Set<string>();
     for (const index of table.indexes) {
+      const duplicateColumn = findDuplicateValue(index.columns);
+      if (duplicateColumn !== undefined) {
+        errors.push(`Table "${tableName}": index contains duplicate column "${duplicateColumn}"`);
+      }
+
       const signature = JSON.stringify({
         columns: index.columns,
         using: index.using ?? null,

@@ -681,6 +681,57 @@ describe('SQL contract validators', () => {
       expect(errors[1]).toContain('duplicate index definition');
     });
 
+    it('rejects duplicate columns inside key, unique, and index definitions', () => {
+      const s = createContract<SqlStorage>({
+        storage: {
+          tables: {
+            user: table(
+              {
+                id: col('int4', 'pg/int4@1'),
+                email: col('text', 'pg/text@1'),
+              },
+              {
+                pk: pk('id', 'id'),
+                uniques: [unique('email', 'email')],
+                indexes: [index('email', 'email')],
+              },
+            ),
+          },
+        },
+      }).storage;
+
+      const errors = validateStorageSemantics(s);
+      expect(errors).toHaveLength(3);
+      expect(errors[0]).toContain('primary key');
+      expect(errors[0]).toContain('duplicate column "id"');
+      expect(errors[1]).toContain('unique constraint');
+      expect(errors[1]).toContain('duplicate column "email"');
+      expect(errors[2]).toContain('index');
+      expect(errors[2]).toContain('duplicate column "email"');
+    });
+
+    it('rejects nullable primary-key columns', () => {
+      const s = createContract<SqlStorage>({
+        storage: {
+          tables: {
+            user: table(
+              {
+                id: col('int4', 'pg/int4@1', true),
+              },
+              {
+                pk: pk('id'),
+              },
+            ),
+          },
+        },
+      }).storage;
+
+      const errors = validateStorageSemantics(s);
+      expect(errors).toHaveLength(1);
+      expect(errors[0]).toContain('primary key column "id"');
+      expect(errors[0]).toContain('NOT NULL');
+    });
+
     it('rejects duplicate foreign key definitions within the same table', () => {
       const s = createContract<SqlStorage>({
         storage: {