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

package/test/lints.test.ts

@@ -0,0 +1,159 @@
+import type { ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
+import type { MiddlewareContext } from '@prisma-next/runtime-executor';
+import {
+  BinaryExpr,
+  ColumnRef,
+  DeleteAst,
+  DerivedTableSource,
+  ParamRef,
+  ProjectionItem,
+  SelectAst,
+  TableSource,
+  UpdateAst,
+} from '@prisma-next/sql-relational-core/ast';
+import { timeouts } from '@prisma-next/test-utils';
+import { describe, expect, it, vi } from 'vitest';
+import { lints } from '../src/middleware/lints';
+
+function createMiddlewareContext(): MiddlewareContext<unknown> {
+  return {
+    contract: {},
+    mode: 'strict' as const,
+    now: () => Date.now(),
+    log: {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    },
+  };
+}
+
+const baseMeta: PlanMeta = {
+  target: 'postgres',
+  storageHash: 'sha256:test',
+  lane: 'dsl',
+  paramDescriptors: [],
+};
+
+type PlanOverrides = Partial<Omit<ExecutionPlan, 'meta'>> & { meta?: Partial<PlanMeta> };
+
+function createPlan(overrides: PlanOverrides): ExecutionPlan {
+  const { meta: metaOverrides, ...rest } = overrides;
+  return {
+    sql: 'SELECT 1',
+    params: [],
+    meta: { ...baseMeta, ...(metaOverrides ?? {}) } as PlanMeta,
+    ...rest,
+  } as ExecutionPlan;
+}
+
+const userTable = TableSource.named('user');
+const idCol = ColumnRef.of('user', 'id');
+
+describe('lints middleware', () => {
+  it(
+    'blocks delete without where',
+    async () => {
+      const plan = createPlan({ ast: DeleteAst.from(userTable) });
+      const mw = lints();
+      const ctx = createMiddlewareContext();
+
+      await expect(mw.beforeExecute?.(plan, ctx)).rejects.toMatchObject({
+        code: 'LINT.DELETE_WITHOUT_WHERE',
+        details: { table: 'user' },
+      });
+    },
+    timeouts.default,
+  );
+
+  it(
+    'blocks update without where',
+    async () => {
+      const plan = createPlan({
+        ast: UpdateAst.table(userTable).withSet({
+          email: ParamRef.of('new@example.com', { name: 'email', codecId: 'pg/text@1' }),
+        }),
+      });
+      const mw = lints();
+      const ctx = createMiddlewareContext();
+
+      await expect(mw.beforeExecute?.(plan, ctx)).rejects.toMatchObject({
+        code: 'LINT.UPDATE_WITHOUT_WHERE',
+        details: { table: 'user' },
+      });
+    },
+    timeouts.default,
+  );
+
+  it(
+    'warns for unbounded selects and selectAll intent',
+    async () => {
+      const ast = SelectAst.from(userTable)
+        .withProjection([ProjectionItem.of('id', idCol)])
+        .withSelectAllIntent({ table: 'user' });
+      const plan = createPlan({ ast });
+      const mw = lints();
+      const ctx = createMiddlewareContext();
+
+      await mw.beforeExecute?.(plan, ctx);
+      expect(ctx.log.warn).toHaveBeenCalledWith(
+        expect.objectContaining({ code: 'LINT.NO_LIMIT', details: { table: 'user' } }),
+      );
+      expect(ctx.log.warn).toHaveBeenCalledWith(
+        expect.objectContaining({ code: 'LINT.SELECT_STAR', details: { table: 'user' } }),
+      );
+    },
+    timeouts.default,
+  );
+
+  it(
+    'uses derived table aliases when reporting unbounded selects',
+    async () => {
+      const derived = DerivedTableSource.as(
+        'user_ids',
+        SelectAst.from(userTable).withProjection([ProjectionItem.of('id', idCol)]),
+      );
+      const ast = SelectAst.from(derived).withProjection([
+        ProjectionItem.of('id', ColumnRef.of('user_ids', 'id')),
+      ]);
+      const plan = createPlan({ ast });
+      const mw = lints();
+      const ctx = createMiddlewareContext();
+
+      await mw.beforeExecute?.(plan, ctx);
+      expect(ctx.log.warn).toHaveBeenCalledWith(
+        expect.objectContaining({
+          code: 'LINT.NO_LIMIT',
+          details: { table: 'user_ids' },
+        }),
+      );
+    },
+    timeouts.default,
+  );
+
+  it(
+    'allows bounded selects and guarded mutations',
+    async () => {
+      const selectPlan = createPlan({
+        ast: SelectAst.from(userTable)
+          .withProjection([ProjectionItem.of('id', idCol)])
+          .withWhere(BinaryExpr.eq(idCol, ParamRef.of(42, { codecId: 'pg/int4@1' })))
+          .withLimit(10),
+      });
+      const updatePlan = createPlan({
+        ast: UpdateAst.table(userTable)
+          .withSet({
+            email: ParamRef.of('new@example.com', { name: 'email', codecId: 'pg/text@1' }),
+          })
+          .withWhere(BinaryExpr.eq(idCol, ParamRef.of(1, { name: 'id', codecId: 'pg/int4@1' }))),
+      });
+      const mw = lints();
+      const ctx = createMiddlewareContext();
+
+      await mw.beforeExecute?.(selectPlan, ctx);
+      await mw.beforeExecute?.(updatePlan, ctx);
+      expect(ctx.log.warn).not.toHaveBeenCalled();
+    },
+    timeouts.default,
+  );
+});

package/test/mutation-default-generators.test.ts

@@ -0,0 +1,254 @@
+import { type Contract, coreHash, executionHash, profileHash } from '@prisma-next/contract/types';
+import type { SqlStorage } from '@prisma-next/sql-contract/types';
+import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import { describe, expect, it } from 'vitest';
+import {
+  createExecutionContext,
+  type SqlExecutionStack,
+  type SqlRuntimeExtensionDescriptor,
+} from '../src/sql-context';
+import {
+  createStubAdapter,
+  createTestAdapterDescriptor,
+  createTestTargetDescriptor,
+} from './utils';
+
+const testContract: Contract<SqlStorage> = {
+  targetFamily: 'sql',
+  target: 'postgres',
+  profileHash: profileHash('sha256:test'),
+  models: {},
+  roots: {},
+  storage: {
+    storageHash: coreHash('sha256:test'),
+    tables: {
+      user: {
+        columns: {
+          id: { nativeType: 'text', codecId: 'pg/text@1', nullable: false },
+        },
+        uniques: [],
+        indexes: [],
+        foreignKeys: [],
+      },
+    },
+  },
+  extensionPacks: {},
+  capabilities: {},
+  meta: {},
+};
+
+function createStack(
+  extensionPacks: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>,
+): SqlExecutionStack<'postgres'> {
+  return {
+    target: createTestTargetDescriptor(),
+    adapter: createTestAdapterDescriptor(createStubAdapter()),
+    extensionPacks,
+  };
+}
+
+describe('composed runtime mutation default generators', () => {
+  it('resolves a pack-contributed generator id', () => {
+    const extension: SqlRuntimeExtensionDescriptor<'postgres'> = {
+      kind: 'extension',
+      id: 'test-mutation-defaults',
+      version: '0.0.1',
+      familyId: 'sql',
+      targetId: 'postgres',
+      codecs: () => createCodecRegistry(),
+      parameterizedCodecs: () => [],
+      mutationDefaultGenerators: () => [
+        {
+          id: 'slugid',
+          generate: () => 'slug-from-pack',
+        },
+      ],
+      create() {
+        return { familyId: 'sql', targetId: 'postgres' };
+      },
+    };
+
+    const context = createExecutionContext({
+      contract: {
+        ...testContract,
+        execution: {
+          executionHash: executionHash('sha256:test'),
+          mutations: {
+            defaults: [
+              {
+                ref: { table: 'user', column: 'id' },
+                onCreate: { kind: 'generator', id: 'slugid' },
+              },
+            ],
+          },
+        },
+      },
+      stack: createStack([extension]),
+    });
+
+    const applied = context.applyMutationDefaults({ op: 'create', table: 'user', values: {} });
+    expect(applied).toEqual([{ column: 'id', value: 'slug-from-pack' }]);
+  });
+
+  it('skips generated default when user provides an explicit value', () => {
+    const extension: SqlRuntimeExtensionDescriptor<'postgres'> = {
+      kind: 'extension',
+      id: 'test-mutation-defaults',
+      version: '0.0.1',
+      familyId: 'sql',
+      targetId: 'postgres',
+      codecs: () => createCodecRegistry(),
+      parameterizedCodecs: () => [],
+      mutationDefaultGenerators: () => [
+        {
+          id: 'slugid',
+          generate: () => 'slug-from-pack',
+        },
+      ],
+      create() {
+        return { familyId: 'sql', targetId: 'postgres' };
+      },
+    };
+
+    const context = createExecutionContext({
+      contract: {
+        ...testContract,
+        execution: {
+          executionHash: executionHash('sha256:test'),
+          mutations: {
+            defaults: [
+              {
+                ref: { table: 'user', column: 'id' },
+                onCreate: { kind: 'generator', id: 'slugid' },
+              },
+            ],
+          },
+        },
+      },
+      stack: createStack([extension]),
+    });
+
+    const applied = context.applyMutationDefaults({
+      op: 'create',
+      table: 'user',
+      values: { id: 'user-provided-value' },
+    });
+    expect(applied).toEqual([]);
+  });
+
+  it('throws error naming both owners when duplicate generator ids are composed', () => {
+    const first: SqlRuntimeExtensionDescriptor<'postgres'> = {
+      kind: 'extension',
+      id: 'first-pack',
+      version: '0.0.1',
+      familyId: 'sql',
+      targetId: 'postgres',
+      codecs: () => createCodecRegistry(),
+      parameterizedCodecs: () => [],
+      mutationDefaultGenerators: () => [{ id: 'duplicate', generate: () => 'first' }],
+      create() {
+        return { familyId: 'sql', targetId: 'postgres' };
+      },
+    };
+    const second: SqlRuntimeExtensionDescriptor<'postgres'> = {
+      kind: 'extension',
+      id: 'second-pack',
+      version: '0.0.1',
+      familyId: 'sql',
+      targetId: 'postgres',
+      codecs: () => createCodecRegistry(),
+      parameterizedCodecs: () => [],
+      mutationDefaultGenerators: () => [{ id: 'duplicate', generate: () => 'second' }],
+      create() {
+        return { familyId: 'sql', targetId: 'postgres' };
+      },
+    };
+
+    expect(() =>
+      createExecutionContext({
+        contract: testContract,
+        stack: createStack([first, second]),
+      }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.DUPLICATE_MUTATION_DEFAULT_GENERATOR',
+        details: expect.objectContaining({
+          existingOwner: 'first-pack',
+          incomingOwner: 'second-pack',
+        }),
+      }),
+    );
+  });
+
+  it('throws stable error when generator id implementation is missing', () => {
+    const context = createExecutionContext({
+      contract: {
+        ...testContract,
+        execution: {
+          executionHash: executionHash('sha256:test'),
+          mutations: {
+            defaults: [
+              {
+                ref: { table: 'user', column: 'id' },
+                onCreate: { kind: 'generator', id: 'unknown-generator' },
+              },
+            ],
+          },
+        },
+      },
+      stack: createStack([]),
+    });
+
+    expect(() =>
+      context.applyMutationDefaults({
+        op: 'create',
+        table: 'user',
+        values: {},
+      }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.MUTATION_DEFAULT_GENERATOR_MISSING',
+      }),
+    );
+  });
+
+  it('does not resolve built-in generator ids without composed contributors', () => {
+    const adapterWithoutMutationDefaultGenerators = {
+      ...createTestAdapterDescriptor(createStubAdapter()),
+      mutationDefaultGenerators: () => [],
+    };
+    const context = createExecutionContext({
+      contract: {
+        ...testContract,
+        execution: {
+          executionHash: executionHash('sha256:test'),
+          mutations: {
+            defaults: [
+              {
+                ref: { table: 'user', column: 'id' },
+                onCreate: { kind: 'generator', id: 'uuidv4' },
+              },
+            ],
+          },
+        },
+      },
+      stack: {
+        target: createTestTargetDescriptor(),
+        adapter: adapterWithoutMutationDefaultGenerators,
+        extensionPacks: [],
+      },
+    });
+
+    expect(() =>
+      context.applyMutationDefaults({
+        op: 'create',
+        table: 'user',
+        values: {},
+      }),
+    ).toThrow(
+      expect.objectContaining({
+        code: 'RUNTIME.MUTATION_DEFAULT_GENERATOR_MISSING',
+      }),
+    );
+  });
+});