@prisma-next/sql-runtime 0.5.0-dev.7 → 0.5.0-dev.9

package/test/lints.test.ts

@@ -1,160 +0,0 @@
-import type { Contract, ExecutionPlan, PlanMeta } from '@prisma-next/contract/types';
-import type { SqlStorage } from '@prisma-next/sql-contract/types';
-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';
-import type { SqlMiddlewareContext } from '../src/middleware/sql-middleware';
-
-function createMiddlewareContext(): SqlMiddlewareContext {
-  return {
-    contract: {} as Contract<SqlStorage>,
-    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

@@ -1,254 +0,0 @@
-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',
-      }),
-    );
-  });
-});