test(scalar-arrays): prove String[]/Int[] read-back via SQL runtime and ORM client

SevInf · claude · SevInf · commit 283c5ba635a5 · 2026-07-02T13:59:12.000Z
Add a sibling to the DateTime[]/Bytes[]/Decimal[] roundtrip covering the plain
scalar element types: author `tags String[]`/`scores Int[]` in PSL, migrate onto
real Postgres, insert, and SELECT back, asserting element-wise decode for
pg/text@1 and pg/int4@1.

Add an ORM-client read-back test: over the same PSL-authored contract, read the
native array columns through orm().&lt;ns&gt;.&lt;model&gt;.select(...).all(), proving the
ORM projects and decodes scalar many:true columns as JS arrays (not just to-many
relations). The PSL path yields a generic Contract&lt;SqlStorage&gt;, so accessors are
index signatures; the narrow row-type array inference is covered by the emitted
contract path.

Co-Authored-By: Claude Opus 4.8 &lt;noreply@anthropic.com&gt;
Signed-off-by: Serhii Tatarintsev &lt;tatarintsev@prisma.io&gt;
diff --git a/test/integration/test/scalar-lists/orm-list-read.integration.test.ts b/test/integration/test/scalar-lists/orm-list-read.integration.test.ts
@@ -0,0 +1,184 @@
+/**
+ * Reads a native scalar-list column (`tags String[]`, `scores Int[]`) back
+ * through the ORM client. A model authored in PSL emits array storage columns
+ * (`pg/text@1`/`pg/int4@1`, `many:true`); after migrating onto a real Postgres
+ * database and inserting a row, `orm().<ns>.<model>.select(...).all()` surfaces
+ * each list column as a decoded JS array — proving the ORM read path projects
+ * and decodes scalar `many` columns element-wise, not just to-many relations.
+ */
+import postgresAdapter from '@prisma-next/adapter-postgres/control';
+import postgresRuntimeAdapter from '@prisma-next/adapter-postgres/runtime';
+import type { Contract } from '@prisma-next/contract/types';
+import postgresControlDriver from '@prisma-next/driver-postgres/control';
+import sql, { INIT_ADDITIVE_POLICY } from '@prisma-next/family-sql/control';
+import { APP_SPACE_ID, createControlStack } from '@prisma-next/framework-components/control';
+import { buildSynthMigrationEdge } from '@prisma-next/migration-tools/aggregate';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { orm } from '@prisma-next/sql-orm-client';
+import { InsertAst, ParamRef, TableSource } from '@prisma-next/sql-relational-core/ast';
+import { planFromAst } from '@prisma-next/sql-relational-core/plan';
+import { createExecutionContext, createSqlExecutionStack } from '@prisma-next/sql-runtime';
+import postgres from '@prisma-next/target-postgres/control';
+import postgresRuntimeTarget from '@prisma-next/target-postgres/runtime';
+import { createDevDatabase, type DevDatabase, timeouts, withClient } from '@prisma-next/test-utils';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { createTestRuntimeFromClient } from '../utils';
+import {
+  authorSqlContractFromPsl,
+  findStorageColumn,
+  listCodecRefFor,
+  postgresFrameworkComponents,
+  tableNameForColumn,
+} from './psl-list-authoring';
+
+const controlStack = createControlStack({
+  family: sql,
+  target: postgres,
+  adapter: postgresAdapter,
+  driver: postgresControlDriver,
+  extensionPacks: [],
+});
+const familyInstance = sql.create(controlStack);
+
+async function migrateContract(
+  connectionString: string,
+  contract: Contract<SqlStorage>,
+): Promise<void> {
+  const driver = await postgresControlDriver.create(connectionString);
+  try {
+    const schema = await familyInstance.introspect({ driver });
+    const planner = postgres.createPlanner(postgresAdapter.create(controlStack));
+    const planResult = planner.plan({
+      contract,
+      schema,
+      policy: INIT_ADDITIVE_POLICY,
+      fromContract: null,
+      frameworkComponents: postgresFrameworkComponents,
+      spaceId: APP_SPACE_ID,
+    });
+    if (planResult.kind !== 'success') {
+      throw new Error(`planner failed: ${JSON.stringify(planResult)}`);
+    }
+
+    const runner = postgres.createRunner(familyInstance);
+    const runResult = await runner.execute({
+      driver,
+      perSpaceOptions: [
+        {
+          space: APP_SPACE_ID,
+          plan: planResult.plan,
+          migrationEdges: [
+            buildSynthMigrationEdge({
+              currentMarkerStorageHash: planResult.plan.origin?.storageHash,
+              destinationStorageHash: planResult.plan.destination.storageHash,
+              operationCount: planResult.plan.operations.length,
+            }),
+          ],
+          driver,
+          destinationContract: contract,
+          policy: INIT_ADDITIVE_POLICY,
+          frameworkComponents: postgresFrameworkComponents,
+        },
+      ],
+    });
+    if (!runResult.ok) {
+      throw new Error(`runner failed: ${JSON.stringify(runResult.failure)}`);
+    }
+  } finally {
+    await driver.close();
+  }
+}
+
+describe.sequential('ORM scalar-list read-back', () => {
+  let database: DevDatabase | undefined;
+
+  beforeAll(async () => {
+    database = await createDevDatabase();
+  }, timeouts.spinUpPpgDev);
+
+  afterAll(async () => {
+    if (database) await database.close();
+  }, timeouts.spinUpPpgDev);
+
+  it(
+    'orm().<model>.select(...).all() surfaces String[]/Int[] columns as arrays',
+    async () => {
+      if (!database) throw new Error('database not initialised');
+
+      const authored = await authorSqlContractFromPsl(`model Item {
+  id     Int      @id
+  tags   String[]
+  scores Int[]
+}`);
+      expect(authored.ok).toBe(true);
+      const contract = authored.contract;
+      if (!contract) throw new Error('authoring produced no contract');
+
+      // Sanity: native array columns (not the jsonb fallback).
+      expect(findStorageColumn(contract, 'tags')).toMatchObject({
+        codecId: 'pg/text@1',
+        many: true,
+      });
+      expect(findStorageColumn(contract, 'scores')).toMatchObject({
+        codecId: 'pg/int4@1',
+        many: true,
+      });
+
+      await withClient(database.connectionString, async (client) => {
+        await client.query('DROP SCHEMA IF EXISTS public CASCADE');
+        await client.query('CREATE SCHEMA public');
+        await client.query('DROP SCHEMA IF EXISTS prisma_contract CASCADE');
+      });
+      await migrateContract(database.connectionString, contract);
+
+      const tableName = tableNameForColumn(contract, 'tags');
+      const table = TableSource.named(tableName);
+      const tagsRef = listCodecRefFor(contract, 'tags');
+      const scoresRef = listCodecRefFor(contract, 'scores');
+      const tags = ['a', 'b', 'c'];
+      const scores = [1, 2, 3];
+
+      await withClient(database.connectionString, async (client) => {
+        const runtime = await createTestRuntimeFromClient(contract, client, {
+          verifyMarker: false,
+        });
+
+        // Seed via the raw runtime; the ORM read path is what's under test.
+        const insert = InsertAst.into(table).withRows([
+          {
+            id: ParamRef.of(1, { codec: { codecId: 'pg/int4@1' } }),
+            tags: ParamRef.of(tags, { codec: tagsRef }),
+            scores: ParamRef.of(scores, { codec: scoresRef }),
+          },
+        ]);
+        await runtime.execute(planFromAst(insert, contract)).toArray();
+
+        const context = createExecutionContext<Contract<SqlStorage>>({
+          contract,
+          stack: createSqlExecutionStack({
+            target: postgresRuntimeTarget,
+            adapter: postgresRuntimeAdapter,
+            extensionPacks: [],
+          }),
+        });
+        const db = orm({ runtime, context });
+
+        // The PSL path yields a generic `Contract<SqlStorage>`, so the ORM's
+        // namespace/model accessors are index signatures (bracket access). The
+        // narrow row-type array inference for `many` columns is proven by the
+        // emitted-contract path; here we prove the runtime read: the ORM
+        // projects and decodes the scalar `many` columns as JS arrays.
+        const publicNamespace = db['public'];
+        if (!publicNamespace) throw new Error('public namespace missing from ORM client');
+        const items = publicNamespace['Item'];
+        if (!items) throw new Error('Item collection missing from ORM client');
+
+        // Single seeded row — result order is trivially deterministic.
+        const rows = await items.select('id', 'tags', 'scores').all();
+
+        expect(rows).toEqual([{ id: 1, tags, scores }]);
+      });
+    },
+    timeouts.spinUpPpgDev,
+  );
+});
diff --git a/test/integration/test/scalar-lists/psl-list-roundtrip.integration.test.ts b/test/integration/test/scalar-lists/psl-list-roundtrip.integration.test.ts
@@ -282,4 +282,83 @@ model Reading {
     },
     timeouts.spinUpPpgDev,
   );
+
+  it(
+    'String[]/Int[] authored in PSL round-trip element values',
+    async () => {
+      if (!database) throw new Error('database not initialised');
+
+      const authored = await authorSqlContractFromPsl(`model Item {
+  id     Int      @id
+  tags   String[]
+  scores Int[]
+}`);
+      expect(authored.ok).toBe(true);
+      const contract = authored.contract;
+      if (!contract) throw new Error('authoring produced no contract');
+
+      // Sanity: each list field lowered to a native array column (not jsonb).
+      expect(findStorageColumn(contract, 'tags')).toMatchObject({
+        codecId: 'pg/text@1',
+        many: true,
+      });
+      expect(findStorageColumn(contract, 'scores')).toMatchObject({
+        codecId: 'pg/int4@1',
+        many: true,
+      });
+
+      await withClient(database.connectionString, async (client) => {
+        await client.query('DROP SCHEMA IF EXISTS public CASCADE');
+        await client.query('CREATE SCHEMA public');
+        await client.query('DROP SCHEMA IF EXISTS prisma_contract CASCADE');
+      });
+      await migrateContract(database.connectionString, contract);
+
+      const tableName = tableNameForColumn(contract, 'tags');
+      const table = TableSource.named(tableName);
+      const tagsRef = listCodecRefFor(contract, 'tags');
+      const scoresRef = listCodecRefFor(contract, 'scores');
+
+      const tags = ['a', 'b', 'c'];
+      const scores = [1, 2, 3];
+
+      await withClient(database.connectionString, async (client) => {
+        const runtime = await createTestRuntimeFromClient(contract, client, {
+          verifyMarker: false,
+        });
+
+        const insert = InsertAst.into(table).withRows([
+          {
+            id: ParamRef.of(1, { codec: { codecId: 'pg/int4@1' } }),
+            tags: ParamRef.of(tags, { codec: tagsRef }),
+            scores: ParamRef.of(scores, { codec: scoresRef }),
+          },
+        ]);
+        await runtime.execute(planFromAst(insert, contract)).toArray();
+
+        const select = SelectAst.from(table)
+          .withProjection([
+            ProjectionItem.of('tags', ColumnRef.of(tableName, 'tags'), tagsRef),
+            ProjectionItem.of('scores', ColumnRef.of(tableName, 'scores'), scoresRef),
+          ])
+          .withWhere(
+            BinaryExpr.eq(
+              ColumnRef.of(tableName, 'id'),
+              ParamRef.of(1, { codec: { codecId: 'pg/int4@1' } }),
+            ),
+          );
+
+        const rows = await runtime.execute(planFromAst(select, contract)).toArray();
+        expect(rows).toHaveLength(1);
+        const row = rows[0] as unknown as {
+          tags: string[];
+          scores: number[];
+        };
+
+        expect(row.tags).toEqual(tags);
+        expect(row.scores).toEqual(scores);
+      });
+    },
+    timeouts.spinUpPpgDev,
+  );
 });
