feat(sql): support id-less models

docs/architecture docs/subsystems/3. Query Lanes.md

@@ -342,6 +342,10 @@ const plan = o.user()
 
 The ORM is optional and layered on top of the DSL.
 
+### Implicit invariant: ORM ops assume a primary key
+
+`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. ORM read/write operations (`findUnique`, `update(where)`, `delete(where)`) assume a single canonical identity to address rows; they have no fallback for id-less models. The current ORM lane has no code referring to `model.id` directly, so id-less models do not break composition today, but adding any ORM op that depends on a primary key against an id-less model will fail at runtime. The long-term fix is a per-model capability (e.g. `sql.ormRequiresPrimaryKey`) gated at composition time; until then, treat id-less models as DSL-only.
+
 ### Shared Collection interface across families
 
 The ORM's `Collection` class with fluent chaining is a shared architectural pattern that works across database families — not just SQL. A comparative analysis with the MongoDB ORM (see [10. MongoDB Family](10.%20MongoDB%20Family.md)) revealed that the consumer-facing surface is fundamentally the same:

packages/1-framework/3-tooling/cli/test/control-api/client.test.ts

@@ -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[],

packages/1-framework/3-tooling/cli/vitest.config.ts

@@ -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'],

packages/1-framework/3-tooling/emitter/test/emitter.roundtrip.test.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({

packages/1-framework/3-tooling/vite-plugin-contract-emit/src/plugin.ts

@@ -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) {

packages/1-framework/3-tooling/vite-plugin-contract-emit/test/plugin.test.ts

@@ -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();