@prisma-next/adapter-postgres 0.4.1 → 0.4.3

package/src/core/control-adapter.ts

@@ -1,5 +1,13 @@
+import type { ContractMarkerRecord } from '@prisma-next/contract/types';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import { parseContractMarkerRow } from '@prisma-next/family-sql/verify';
+import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import type {
+  AnyQueryAst,
+  LoweredStatement,
+  LowererContext,
+} from '@prisma-next/sql-relational-core/ast';
 import type {
   DependencyIR,
   PrimaryKey,
@@ -11,9 +19,13 @@ import type {
   SqlTableIR,
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
+import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
+import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
 import { ifDefined } from '@prisma-next/utils/defined';
-import { parsePostgresDefault } from './default-normalizer';
+import { createPostgresBuiltinCodecLookup } from './codec-lookup';
 import { pgEnumControlHooks } from './enum-control-hooks';
+import { renderLoweredSql } from './sql-renderer';
+import type { PostgresContract } from './types';
 
 /**
  * Postgres control plane adapter for control-plane operations like introspection.
@@ -23,6 +35,19 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   readonly familyId = 'sql' as const;
   readonly targetId = 'postgres' as const;
 
+  private readonly codecLookup: CodecLookup;
+
+  /**
+   * @param codecLookup - Codec lookup used by the SQL renderer to resolve
+   *   per-codec metadata at lower-time. Defaults to a Postgres-builtins-only
+   *   lookup when omitted. Stack-aware callers
+   *   (`SqlControlAdapterDescriptor.create(stack)`) supply
+   *   `stack.codecLookup` so extension codecs are visible to the renderer.
+   */
+  constructor(codecLookup?: CodecLookup) {
+    this.codecLookup = codecLookup ?? createPostgresBuiltinCodecLookup();
+  }
+
   /**
    * Target-specific normalizer for raw Postgres default expressions.
    * Used by schema verification to normalize raw defaults before comparison.
@@ -36,6 +61,68 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   readonly normalizeNativeType = normalizeSchemaNativeType;
 
+  /**
+   * Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
+   *
+   * Delegates to the shared `renderLoweredSql` renderer so the control adapter
+   * emits byte-identical SQL to `PostgresAdapterImpl.lower()` for the same AST
+   * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+   * without instantiating the runtime adapter.
+   */
+  lower(ast: AnyQueryAst, context: LowererContext<unknown>): LoweredStatement {
+    return renderLoweredSql(ast, context.contract as PostgresContract, this.codecLookup);
+  }
+
+  /**
+   * Reads the contract marker from `prisma_contract.marker`. Probes
+   * `information_schema.tables` first so a fresh database (where the
+   * `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+   * "relation does not exist" error — some Postgres wire-protocol clients
+   * (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+   * parse errors, so we probe before reading.
+   */
+  async readMarker(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+  ): Promise<ContractMarkerRecord | null> {
+    const exists = await driver.query(
+      `select 1
+       from information_schema.tables
+       where table_schema = $1 and table_name = $2`,
+      ['prisma_contract', 'marker'],
+    );
+    if (exists.rows.length === 0) {
+      return null;
+    }
+
+    const result = await driver.query<{
+      core_hash: string;
+      profile_hash: string;
+      contract_json: unknown | null;
+      canonical_version: number | null;
+      updated_at: Date | string;
+      app_tag: string | null;
+      meta: unknown | null;
+      invariants: readonly string[];
+    }>(
+      `select
+         core_hash,
+         profile_hash,
+         contract_json,
+         canonical_version,
+         updated_at,
+         app_tag,
+         meta,
+         invariants
+       from prisma_contract.marker
+       where id = $1`,
+      [1],
+    );
+
+    const row = result.rows[0];
+    if (!row) return null;
+    return parseContractMarkerRow(row);
+  }
+
   /**
    * Introspects a Postgres database schema and returns a raw SqlSchemaIR.
    *
@@ -453,52 +540,6 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
   }
 }
 
-/**
- * Pre-computed lookup map for simple prefix-based type normalization.
- * Maps short Postgres type names to their canonical SQL names.
- * Using a Map for O(1) lookup instead of multiple startsWith checks.
- */
-const TYPE_PREFIX_MAP: ReadonlyMap<string, string> = new Map([
-  ['varchar', 'character varying'],
-  ['bpchar', 'character'],
-  ['varbit', 'bit varying'],
-]);
-
-/**
- * Normalizes a Postgres schema native type to its canonical form for comparison.
- *
- * Uses a pre-computed lookup map for simple prefix replacements (O(1))
- * and handles complex temporal type normalization separately.
- */
-export function normalizeSchemaNativeType(nativeType: string): string {
-  const trimmed = nativeType.trim();
-
-  // Fast path: check simple prefix replacements using the lookup map
-  for (const [prefix, replacement] of TYPE_PREFIX_MAP) {
-    if (trimmed.startsWith(prefix)) {
-      return replacement + trimmed.slice(prefix.length);
-    }
-  }
-
-  // Temporal types with time zone handling
-  // Check for 'with time zone' suffix first (more specific)
-  if (trimmed.includes(' with time zone')) {
-    if (trimmed.startsWith('timestamp')) {
-      return `timestamptz${trimmed.slice(9).replace(' with time zone', '')}`;
-    }
-    if (trimmed.startsWith('time')) {
-      return `timetz${trimmed.slice(4).replace(' with time zone', '')}`;
-    }
-  }
-
-  // Handle 'without time zone' suffix - just strip it
-  if (trimmed.includes(' without time zone')) {
-    return trimmed.replace(' without time zone', '');
-  }
-
-  return trimmed;
-}
-
 function normalizeFormattedType(formattedType: string, dataType: string, udtName: string): string {
   if (formattedType === 'integer') {
     return 'int4';

package/src/core/descriptor-meta.ts

@@ -1,5 +1,12 @@
 import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';
 import type { SqlOperationDescriptor } from '@prisma-next/sql-operations';
+import {
+  buildOperation,
+  type CodecExpression,
+  type Expression,
+  type TraitExpression,
+  toExpr,
+} from '@prisma-next/sql-relational-core/expression';
 import {
   PG_BIT_CODEC_ID,
   PG_BOOL_CODEC_ID,
@@ -29,8 +36,8 @@ import {
   SQL_TEXT_CODEC_ID,
   SQL_TIMESTAMP_CODEC_ID,
   SQL_VARCHAR_CODEC_ID,
-} from './codec-ids';
-import { codecDefinitions } from './codecs';
+} from '@prisma-next/target-postgres/codec-ids';
+import { codecDefinitions } from '@prisma-next/target-postgres/codecs';
 import { pgEnumControlHooks } from './enum-control-hooks';
 
 // ============================================================================
@@ -40,7 +47,7 @@ import { pgEnumControlHooks } from './enum-control-hooks';
 /** Creates a type import spec for codec types */
 const codecTypeImport = (named: string) =>
   ({
-    package: '@prisma-next/adapter-postgres/codec-types',
+    package: '@prisma-next/target-postgres/codec-types',
     named,
     alias: named,
   }) as const;
@@ -128,17 +135,28 @@ const identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) =>
 // Descriptor metadata
 // ============================================================================
 
-export const postgresQueryOperations: readonly SqlOperationDescriptor[] = [
-  {
-    method: 'ilike',
-    args: [
-      { traits: ['textual'], nullable: false },
-      { codecId: PG_TEXT_CODEC_ID, nullable: false },
-    ],
-    returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
-    lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
-  },
-];
+type CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;
+
+export function postgresQueryOperations<
+  CT extends CodecTypesBase,
+>(): readonly SqlOperationDescriptor[] {
+  return [
+    {
+      method: 'ilike',
+      self: { traits: ['textual'] },
+      impl: (
+        self: TraitExpression<readonly ['textual'], false, CT>,
+        pattern: CodecExpression<'pg/text@1', false, CT>,
+      ): Expression<{ codecId: 'pg/bool@1'; nullable: false }> =>
+        buildOperation({
+          method: 'ilike',
+          args: [toExpr(self), toExpr(pattern, PG_TEXT_CODEC_ID)],
+          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },
+          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },
+        }),
+    },
+  ];
+}
 
 export const postgresAdapterDescriptorMeta = {
   kind: 'adapter',
@@ -164,13 +182,13 @@ export const postgresAdapterDescriptorMeta = {
     codecTypes: {
       codecInstances: Object.values(codecDefinitions).map((def) => def.codec),
       import: {
-        package: '@prisma-next/adapter-postgres/codec-types',
+        package: '@prisma-next/target-postgres/codec-types',
         named: 'CodecTypes',
         alias: 'PgTypes',
       },
       typeImports: [
         {
-          package: '@prisma-next/adapter-postgres/codec-types',
+          package: '@prisma-next/target-postgres/codec-types',
           named: 'JsonValue',
           alias: 'JsonValue',
         },

package/src/core/enum-control-hooks.ts

@@ -3,8 +3,13 @@ import type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/
 import { arraysEqual } from '@prisma-next/family-sql/schema-verify';
 import type { SqlStorage, StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
-import { PG_ENUM_CODEC_ID } from './codec-ids';
-import { escapeLiteral, qualifyName, quoteIdentifier, validateEnumValueLength } from './sql-utils';
+import { PG_ENUM_CODEC_ID } from '@prisma-next/target-postgres/codec-ids';
+import {
+  escapeLiteral,
+  qualifyName,
+  quoteIdentifier,
+  validateEnumValueLength,
+} from '@prisma-next/target-postgres/sql-utils';
 
 /**
  * Postgres enum control hooks.