@prisma-next/adapter-postgres 0.3.0-dev.7 → 0.3.0-dev.70

package/src/core/adapter.ts

@@ -2,26 +2,51 @@ import type {
   Adapter,
   AdapterProfile,
   BinaryExpr,
+  CodecParamsDescriptor,
   ColumnRef,
   DeleteAst,
-  ExistsExpr,
   IncludeRef,
   InsertAst,
   JoinAst,
+  JoinOnExpr,
+  ListLiteralExpr,
   LiteralExpr,
   LowererContext,
+  NullCheckExpr,
   OperationExpr,
   ParamRef,
   QueryAst,
   SelectAst,
   UpdateAst,
+  WhereExpr,
 } from '@prisma-next/sql-relational-core/ast';
 import { createCodecRegistry, isOperationExpr } from '@prisma-next/sql-relational-core/ast';
+import { ifDefined } from '@prisma-next/utils/defined';
+import { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from './codec-ids';
 import { codecDefinitions } from './codecs';
+import { escapeLiteral } from './sql-utils';
 import type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';
 
 const VECTOR_CODEC_ID = 'pg/vector@1' as const;
 
+function getCodecParamCast(codecId: string | undefined): string | undefined {
+  if (codecId === VECTOR_CODEC_ID) {
+    return 'vector';
+  }
+  if (codecId === PG_JSON_CODEC_ID) {
+    return 'json';
+  }
+  if (codecId === PG_JSONB_CODEC_ID) {
+    return 'jsonb';
+  }
+  return undefined;
+}
+
+function renderTypedParam(index: number, codecId: string | undefined): string {
+  const cast = getCodecParamCast(codecId);
+  return cast ? `$${index}::${cast}` : `$${index}`;
+}
+
 const defaultCapabilities = Object.freeze({
   postgres: {
     orderBy: true,
@@ -30,8 +55,27 @@ const defaultCapabilities = Object.freeze({
     jsonAgg: true,
     returning: true,
   },
+  sql: {
+    enums: true,
+  },
 });
 
+type AdapterCodec = (typeof codecDefinitions)[keyof typeof codecDefinitions]['codec'];
+type ParameterizedCodec = AdapterCodec & {
+  readonly paramsSchema: NonNullable<AdapterCodec['paramsSchema']>;
+};
+
+const parameterizedCodecs: ReadonlyArray<CodecParamsDescriptor> = Object.values(codecDefinitions)
+  .map((definition) => definition.codec)
+  .filter((codec): codec is ParameterizedCodec => codec.paramsSchema !== undefined)
+  .map((codec) =>
+    Object.freeze({
+      codecId: codec.id,
+      paramsSchema: codec.paramsSchema,
+      ...ifDefined('init', codec.init),
+    }),
+  );
+
 class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, PostgresLoweredStatement> {
   // These fields make the adapter instance structurally compatible with
   // RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.
@@ -56,6 +100,10 @@ class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, Postgre
     });
   }
 
+  parameterizedCodecs(): ReadonlyArray<CodecParamsDescriptor> {
+    return parameterizedCodecs;
+  }
+
   lower(ast: QueryAst, context: LowererContext<PostgresContract>) {
     let sql: string;
     const params = context.params ? [...context.params] : [];
@@ -134,29 +182,73 @@ function renderProjection(ast: SelectAst, contract?: PostgresContract): string {
     .join(', ');
 }
 
-function renderWhere(expr: BinaryExpr | ExistsExpr, contract?: PostgresContract): string {
+function renderWhere(expr: WhereExpr, contract?: PostgresContract): string {
   if (expr.kind === 'exists') {
     const notKeyword = expr.not ? 'NOT ' : '';
     const subquery = renderSelect(expr.subquery, contract);
     return `${notKeyword}EXISTS (${subquery})`;
   }
+  if (expr.kind === 'nullCheck') {
+    return renderNullCheck(expr, contract);
+  }
+  if (expr.kind === 'and') {
+    if (expr.exprs.length === 0) {
+      return 'TRUE';
+    }
+    return `(${expr.exprs.map((part) => renderWhere(part, contract)).join(' AND ')})`;
+  }
+  if (expr.kind === 'or') {
+    if (expr.exprs.length === 0) {
+      return 'FALSE';
+    }
+    return `(${expr.exprs.map((part) => renderWhere(part, contract)).join(' OR ')})`;
+  }
   return renderBinary(expr, contract);
 }
 
+function renderNullCheck(expr: NullCheckExpr, contract?: PostgresContract): string {
+  const rendered = renderExpr(expr.expr as ColumnRef | OperationExpr, contract);
+  // Only wrap in parentheses if it's an operation expression
+  const renderedExpr = isOperationExpr(expr.expr) ? `(${rendered})` : rendered;
+  return expr.isNull ? `${renderedExpr} IS NULL` : `${renderedExpr} IS NOT NULL`;
+}
+
 function renderBinary(expr: BinaryExpr, contract?: PostgresContract): string {
+  if (expr.right.kind === 'listLiteral' && expr.right.values.length === 0) {
+    if (expr.op === 'in') {
+      return 'FALSE';
+    }
+    if (expr.op === 'notIn') {
+      return 'TRUE';
+    }
+  }
+
   const leftExpr = expr.left as ColumnRef | OperationExpr;
   const left = renderExpr(leftExpr, contract);
-  // Handle both ParamRef and ColumnRef on the right side
-  // (ColumnRef can appear in EXISTS subqueries for correlation)
-  const rightExpr = expr.right as ParamRef | ColumnRef;
-  const right =
-    rightExpr.kind === 'col'
-      ? renderColumn(rightExpr)
-      : renderParam(rightExpr as ParamRef, contract);
-  // Only wrap in parentheses if it's an operation expression
   const leftRendered = isOperationExpr(leftExpr) ? `(${left})` : left;
+  const leftCol = leftExpr.kind === 'col' ? leftExpr : undefined;
+
+  const rightExpr = expr.right;
+  let right: string;
+  if (rightExpr.kind === 'listLiteral') {
+    right = renderListLiteral(
+      rightExpr as ListLiteralExpr,
+      contract,
+      leftCol?.table,
+      leftCol?.column,
+    );
+  } else if (rightExpr.kind === 'literal') {
+    right = renderLiteral(rightExpr);
+  } else if (rightExpr.kind === 'col') {
+    right = renderColumn(rightExpr);
+  } else if (rightExpr.kind === 'param') {
+    right = renderParam(rightExpr, contract, leftCol?.table, leftCol?.column);
+  } else if (rightExpr.kind === 'operation') {
+    right = renderOperation(rightExpr, contract);
+  } else {
+    right = renderColumn(rightExpr as ColumnRef);
+  }
 
-  // Map operators to SQL symbols
   const operatorMap: Record<BinaryExpr['op'], string> = {
     eq: '=',
     neq: '!=',
@@ -164,11 +256,32 @@ function renderBinary(expr: BinaryExpr, contract?: PostgresContract): string {
     lt: '<',
     gte: '>=',
     lte: '<=',
+    like: 'LIKE',
+    ilike: 'ILIKE',
+    in: 'IN',
+    notIn: 'NOT IN',
   };
 
   return `${leftRendered} ${operatorMap[expr.op]} ${right}`;
 }
 
+function renderListLiteral(
+  expr: ListLiteralExpr,
+  contract?: PostgresContract,
+  tableName?: string,
+  columnName?: string,
+): string {
+  if (expr.values.length === 0) {
+    return '(NULL)';
+  }
+  const values = expr.values
+    .map((v) =>
+      v.kind === 'param' ? renderParam(v, contract, tableName, columnName) : renderLiteral(v),
+    )
+    .join(', ');
+  return `(${values})`;
+}
+
 function renderColumn(ref: ColumnRef): string {
   return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
 }
@@ -186,20 +299,17 @@ function renderParam(
   tableName?: string,
   columnName?: string,
 ): string {
-  // Cast vector parameters to vector type for PostgreSQL
   if (contract && tableName && columnName) {
     const tableMeta = contract.storage.tables[tableName];
     const columnMeta = tableMeta?.columns[columnName];
-    if (columnMeta?.codecId === VECTOR_CODEC_ID) {
-      return `$${ref.index}::vector`;
-    }
+    return renderTypedParam(ref.index, columnMeta?.codecId);
   }
   return `$${ref.index}`;
 }
 
 function renderLiteral(expr: LiteralExpr): string {
   if (typeof expr.value === 'string') {
-    return `'${expr.value.replace(/'/g, "''")}'`;
+    return `'${escapeLiteral(expr.value)}'`;
   }
   if (typeof expr.value === 'number' || typeof expr.value === 'boolean') {
     return String(expr.value);
@@ -248,20 +358,20 @@ function renderOperation(expr: OperationExpr, contract?: PostgresContract): stri
   return result;
 }
 
-function renderJoin(join: JoinAst, _contract?: PostgresContract): string {
+function renderJoin(join: JoinAst, contract?: PostgresContract): string {
   const joinType = join.joinType.toUpperCase();
   const table = quoteIdentifier(join.table.name);
-  const onClause = renderJoinOn(join.on);
+  const onClause = renderJoinOn(join.on, contract);
   return `${joinType} JOIN ${table} ON ${onClause}`;
 }
 
-function renderJoinOn(on: JoinAst['on']): string {
+function renderJoinOn(on: JoinOnExpr, contract?: PostgresContract): string {
   if (on.kind === 'eqCol') {
     const left = renderColumn(on.left);
     const right = renderColumn(on.right);
     return `${left} = ${right}`;
   }
-  throw new Error(`Unsupported join ON expression kind: ${on.kind}`);
+  return renderWhere(on, contract);
 }
 
 function renderInclude(
@@ -281,7 +391,7 @@ function renderInclude(
   const jsonBuildObject = `json_build_object(${childProjection})`;
 
   // Build the ON condition from the include's ON clause - this goes in the WHERE clause
-  const onCondition = renderJoinOn(include.child.on);
+  const onCondition = renderJoinOn(include.child.on, contract);
 
   // Build WHERE clause: combine ON condition with any additional WHERE clauses
   let whereClause = ` WHERE ${onCondition}`;
@@ -371,8 +481,7 @@ function renderInsert(ast: InsertAst, contract: PostgresContract): string {
   const values = Object.entries(ast.values).map(([colName, val]) => {
     if (val.kind === 'param') {
       const columnMeta = tableMeta?.columns[colName];
-      const isVector = columnMeta?.codecId === VECTOR_CODEC_ID;
-      return isVector ? `$${val.index}::vector` : `$${val.index}`;
+      return renderTypedParam(val.index, columnMeta?.codecId);
     }
     if (val.kind === 'col') {
       return `${quoteIdentifier(val.table)}.${quoteIdentifier(val.column)}`;
@@ -380,7 +489,10 @@ function renderInsert(ast: InsertAst, contract: PostgresContract): string {
     throw new Error(`Unsupported value kind in INSERT: ${(val as { kind: string }).kind}`);
   });
 
-  const insertClause = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${values.join(', ')})`;
+  const insertClause =
+    columns.length === 0
+      ? `INSERT INTO ${table} DEFAULT VALUES`
+      : `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${values.join(', ')})`;
   const returningClause = ast.returning?.length
     ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
     : '';
@@ -396,8 +508,7 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract): string {
     let value: string;
     if (val.kind === 'param') {
       const columnMeta = tableMeta?.columns[col];
-      const isVector = columnMeta?.codecId === VECTOR_CODEC_ID;
-      value = isVector ? `$${val.index}::vector` : `$${val.index}`;
+      value = renderTypedParam(val.index, columnMeta?.codecId);
     } else if (val.kind === 'col') {
       value = `${quoteIdentifier(val.table)}.${quoteIdentifier(val.column)}`;
     } else {
@@ -406,7 +517,7 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract): string {
     return `${column} = ${value}`;
   });
 
-  const whereClause = ` WHERE ${renderBinary(ast.where, contract)}`;
+  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract)}` : '';
   const returningClause = ast.returning?.length
     ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
     : '';
@@ -416,7 +527,7 @@ function renderUpdate(ast: UpdateAst, contract: PostgresContract): string {
 
 function renderDelete(ast: DeleteAst, contract?: PostgresContract): string {
   const table = quoteIdentifier(ast.table.name);
-  const whereClause = ` WHERE ${renderBinary(ast.where, contract)}`;
+  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract)}` : '';
   const returningClause = ast.returning?.length
     ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
     : '';

package/src/core/codec-ids.ts

@@ -0,0 +1,28 @@
+export {
+  SQL_CHAR_CODEC_ID,
+  SQL_FLOAT_CODEC_ID,
+  SQL_INT_CODEC_ID,
+  SQL_VARCHAR_CODEC_ID,
+} from '@prisma-next/sql-relational-core/ast';
+export const PG_TEXT_CODEC_ID = 'pg/text@1' as const;
+export const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;
+export const PG_CHAR_CODEC_ID = 'pg/char@1' as const;
+export const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;
+export const PG_INT_CODEC_ID = 'pg/int@1' as const;
+export const PG_INT2_CODEC_ID = 'pg/int2@1' as const;
+export const PG_INT4_CODEC_ID = 'pg/int4@1' as const;
+export const PG_INT8_CODEC_ID = 'pg/int8@1' as const;
+export const PG_FLOAT_CODEC_ID = 'pg/float@1' as const;
+export const PG_FLOAT4_CODEC_ID = 'pg/float4@1' as const;
+export const PG_FLOAT8_CODEC_ID = 'pg/float8@1' as const;
+export const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;
+export const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;
+export const PG_BIT_CODEC_ID = 'pg/bit@1' as const;
+export const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;
+export const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;
+export const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;
+export const PG_TIME_CODEC_ID = 'pg/time@1' as const;
+export const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;
+export const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;
+export const PG_JSON_CODEC_ID = 'pg/json@1' as const;
+export const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;