@prisma-next/adapter-postgres 0.4.1 → 0.4.3

package/src/core/default-normalizer.ts

@@ -1,145 +0,0 @@
-import type { ColumnDefault } from '@prisma-next/contract/types';
-
-/**
- * Pre-compiled regex patterns for performance.
- * These are compiled once at module load time rather than on each function call.
- */
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-
-/**
- * Returns the canonical expression for a timestamp default function, or undefined
- * if the expression is not a recognized timestamp default.
- *
- * Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:
- * - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'
- * - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'
- *
- * These are semantically different in Postgres: now() returns the transaction
- * start time (constant within a transaction), while clock_timestamp() returns
- * the actual wall-clock time (can differ across rows in a single INSERT).
- */
-function canonicalizeTimestampDefault(expr: string): string | undefined {
-  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';
-  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';
-
-  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;
-
-  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();
-
-  // Strip outer parentheses
-  if (inner.startsWith('(') && inner.endsWith(')')) {
-    inner = inner.slice(1, -1).trim();
-  }
-
-  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';
-  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';
-
-  // Handle 'now'::text form (Postgres casts the string literal 'now' through ::text)
-  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();
-  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';
-
-  return undefined;
-}
-
-/**
- * Parses a raw Postgres column default expression into a normalized ColumnDefault.
- * This enables semantic comparison between contract defaults and introspected schema defaults.
- *
- * Used by the migration diff layer to normalize raw database defaults during comparison,
- * keeping the introspection layer focused on faithful data capture.
- *
- * @param rawDefault - Raw default expression from information_schema.columns.column_default
- * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
- * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
- */
-export function parsePostgresDefault(
-  rawDefault: string,
-  nativeType?: string,
-): ColumnDefault | undefined {
-  const trimmed = rawDefault.trim();
-  const normalizedType = nativeType?.toLowerCase();
-  const isBigInt = normalizedType === 'bigint' || normalizedType === 'int8';
-
-  // Autoincrement: nextval('tablename_column_seq'::regclass)
-  if (NEXTVAL_PATTERN.test(trimmed)) {
-    return { kind: 'function', expression: 'autoincrement()' };
-  }
-
-  // Timestamp defaults: now()/CURRENT_TIMESTAMP → 'now()', clock_timestamp() → 'clock_timestamp()'
-  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-  if (canonicalTimestamp) {
-    return { kind: 'function', expression: canonicalTimestamp };
-  }
-
-  // gen_random_uuid()
-  if (UUID_PATTERN.test(trimmed)) {
-    return { kind: 'function', expression: 'gen_random_uuid()' };
-  }
-
-  // uuid_generate_v4() from uuid-ossp extension
-  if (UUID_OSSP_PATTERN.test(trimmed)) {
-    return { kind: 'function', expression: 'gen_random_uuid()' };
-  }
-
-  // NULL or NULL::type — explicit null default
-  if (NULL_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: null };
-  }
-
-  // Boolean literals
-  if (TRUE_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: true };
-  }
-  if (FALSE_PATTERN.test(trimmed)) {
-    return { kind: 'literal', value: false };
-  }
-
-  // Numeric literals (integer or decimal)
-  if (NUMERIC_PATTERN.test(trimmed)) {
-    const num = Number(trimmed);
-    if (!Number.isFinite(num)) return undefined;
-    if (isBigInt && !Number.isSafeInteger(num)) {
-      return { kind: 'literal', value: trimmed };
-    }
-    return { kind: 'literal', value: num };
-  }
-
-  // String literals: 'value'::type or just 'value'
-  // Match: 'some text'::text, 'hello'::character varying, 'value', etc.
-  // Strip the ::type cast so the normalized expression matches what contract authors write.
-  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-  if (stringMatch?.[1] !== undefined) {
-    const unescaped = stringMatch[1].replace(/''/g, "'");
-    if (normalizedType === 'json' || normalizedType === 'jsonb') {
-      try {
-        return { kind: 'literal', value: JSON.parse(unescaped) };
-      } catch {
-        // Keep legacy behavior for malformed/non-JSON string content.
-      }
-    }
-    if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {
-      const num = Number(unescaped);
-      if (Number.isSafeInteger(num)) {
-        return { kind: 'literal', value: num };
-      }
-      return { kind: 'literal', value: unescaped };
-    }
-    return { kind: 'literal', value: unescaped };
-  }
-
-  // Unrecognized expression - return as a function with the raw expression
-  // This preserves the information for debugging while still being comparable
-  return { kind: 'function', expression: trimmed };
-}

package/src/core/json-schema-type-expression.ts

@@ -1,131 +0,0 @@
-type JsonSchemaRecord = Record<string, unknown>;
-
-const MAX_DEPTH = 32;
-
-function isRecord(value: unknown): value is JsonSchemaRecord {
-  return typeof value === 'object' && value !== null;
-}
-
-function escapeStringLiteral(str: string): string {
-  return str
-    .replace(/\\/g, '\\\\')
-    .replace(/'/g, "\\'")
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r');
-}
-
-function quotePropertyKey(key: string): string {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeStringLiteral(key)}'`;
-}
-
-function renderLiteral(value: unknown): string {
-  if (typeof value === 'string') {
-    return `'${escapeStringLiteral(value)}'`;
-  }
-  if (typeof value === 'number' || typeof value === 'boolean') {
-    return String(value);
-  }
-  if (value === null) {
-    return 'null';
-  }
-  return 'unknown';
-}
-
-function renderUnion(items: readonly unknown[], depth: number): string {
-  const rendered = items.map((item) => render(item, depth));
-  return rendered.join(' | ');
-}
-
-function renderObjectType(schema: JsonSchemaRecord, depth: number): string {
-  const properties = isRecord(schema['properties']) ? schema['properties'] : {};
-  const required = Array.isArray(schema['required'])
-    ? new Set(schema['required'].filter((key): key is string => typeof key === 'string'))
-    : new Set<string>();
-  const keys = Object.keys(properties).sort((left, right) => left.localeCompare(right));
-
-  if (keys.length === 0) {
-    const additionalProperties = schema['additionalProperties'];
-    if (additionalProperties === true || additionalProperties === undefined) {
-      return 'Record<string, unknown>';
-    }
-    return `Record<string, ${render(additionalProperties, depth)}>`;
-  }
-
-  const renderedProperties = keys.map((key) => {
-    const valueSchema = (properties as JsonSchemaRecord)[key];
-    const optionalMarker = required.has(key) ? '' : '?';
-    return `${quotePropertyKey(key)}${optionalMarker}: ${render(valueSchema, depth)}`;
-  });
-
-  return `{ ${renderedProperties.join('; ')} }`;
-}
-
-function renderArrayType(schema: JsonSchemaRecord, depth: number): string {
-  if (Array.isArray(schema['items'])) {
-    return `readonly [${schema['items'].map((item) => render(item, depth)).join(', ')}]`;
-  }
-
-  if (schema['items'] !== undefined) {
-    const itemType = render(schema['items'], depth);
-    const needsParens = itemType.includes(' | ') || itemType.includes(' & ');
-    return needsParens ? `(${itemType})[]` : `${itemType}[]`;
-  }
-
-  return 'unknown[]';
-}
-
-function render(schema: unknown, depth: number): string {
-  if (depth > MAX_DEPTH || !isRecord(schema)) {
-    return 'JsonValue';
-  }
-
-  const nextDepth = depth + 1;
-
-  if ('const' in schema) {
-    return renderLiteral(schema['const']);
-  }
-
-  if (Array.isArray(schema['enum'])) {
-    return schema['enum'].map((value) => renderLiteral(value)).join(' | ');
-  }
-
-  if (Array.isArray(schema['oneOf'])) {
-    return renderUnion(schema['oneOf'], nextDepth);
-  }
-
-  if (Array.isArray(schema['anyOf'])) {
-    return renderUnion(schema['anyOf'], nextDepth);
-  }
-
-  if (Array.isArray(schema['allOf'])) {
-    return schema['allOf'].map((item) => render(item, nextDepth)).join(' & ');
-  }
-
-  if (Array.isArray(schema['type'])) {
-    return schema['type'].map((item) => render({ ...schema, type: item }, nextDepth)).join(' | ');
-  }
-
-  switch (schema['type']) {
-    case 'string':
-      return 'string';
-    case 'number':
-    case 'integer':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'null':
-      return 'null';
-    case 'array':
-      return renderArrayType(schema, nextDepth);
-    case 'object':
-      return renderObjectType(schema, nextDepth);
-    default:
-      break;
-  }
-
-  return 'JsonValue';
-}
-
-export function renderTypeScriptTypeFromJsonSchema(schema: unknown): string {
-  return render(schema, 0);
-}

package/src/core/json-schema-validator.ts

@@ -1,53 +0,0 @@
-import type {
-  JsonSchemaValidateFn,
-  JsonSchemaValidationError,
-  JsonSchemaValidationResult,
-} from '@prisma-next/sql-relational-core/query-lane-context';
-import Ajv from 'ajv';
-
-export type { JsonSchemaValidateFn, JsonSchemaValidationError, JsonSchemaValidationResult };
-
-/**
- * Shared Ajv instance for all JSON Schema validators.
- * Reusing a single instance avoids ~50-100KB memory overhead per compiled schema.
- */
-let sharedAjv: Ajv | undefined;
-
-function getSharedAjv(): Ajv {
-  if (!sharedAjv) {
-    sharedAjv = new Ajv({ allErrors: false, strict: false });
-  }
-  return sharedAjv;
-}
-
-/**
- * Compiles a JSON Schema object into a reusable validate function using Ajv.
- *
- * The returned function validates a value against the schema and returns
- * a structured result with error details on failure.
- *
- * Uses a shared Ajv instance and fail-fast mode (`allErrors: false`)
- * to minimize memory and CPU overhead.
- *
- * @param schema - A JSON Schema object (draft-07 compatible)
- * @returns A validate function
- */
-export function compileJsonSchemaValidator(schema: Record<string, unknown>): JsonSchemaValidateFn {
-  const ajv = getSharedAjv();
-  const validate = ajv.compile(schema);
-
-  return (value: unknown): JsonSchemaValidationResult => {
-    const valid = validate(value);
-    if (valid) {
-      return { valid: true };
-    }
-
-    const errors: JsonSchemaValidationError[] = (validate.errors ?? []).map((err) => ({
-      path: err.instancePath || '/',
-      message: err.message ?? 'unknown validation error',
-      keyword: err.keyword,
-    }));
-
-    return { valid: false, errors };
-  };
-}

package/src/core/sql-utils.ts

@@ -1,111 +0,0 @@
-/**
- * Shared SQL utility functions for the Postgres adapter.
- *
- * These functions handle safe SQL identifier and literal escaping
- * with security validations to prevent injection and encoding issues.
- */
-
-/**
- * Error thrown when an invalid SQL identifier or literal is detected.
- * Boundary layers map this to structured envelopes.
- */
-export class SqlEscapeError extends Error {
-  constructor(
-    message: string,
-    public readonly value: string,
-    public readonly kind: 'identifier' | 'literal',
-  ) {
-    super(message);
-    this.name = 'SqlEscapeError';
-  }
-}
-
-/**
- * Maximum length for PostgreSQL identifiers (NAMEDATALEN - 1).
- */
-const MAX_IDENTIFIER_LENGTH = 63;
-
-/**
- * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
- *
- * Security validations:
- * - Rejects null bytes which could cause truncation or unexpected behavior
- * - Rejects empty identifiers
- * - Warns on identifiers exceeding PostgreSQL's 63-character limit
- *
- * @throws {SqlEscapeError} If the identifier contains null bytes or is empty
- */
-export function quoteIdentifier(identifier: string): string {
-  if (identifier.length === 0) {
-    throw new SqlEscapeError('Identifier cannot be empty', identifier, 'identifier');
-  }
-  if (identifier.includes('\0')) {
-    throw new SqlEscapeError(
-      'Identifier cannot contain null bytes',
-      identifier.replace(/\0/g, '\\0'),
-      'identifier',
-    );
-  }
-  // PostgreSQL will truncate identifiers longer than 63 characters.
-  // We don't throw here because it's not a security issue, but callers should be aware.
-  if (identifier.length > MAX_IDENTIFIER_LENGTH) {
-    // Log warning in development, but don't fail - PostgreSQL handles truncation
-    console.warn(
-      `Identifier "${identifier.slice(0, 20)}..." exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`,
-    );
-  }
-  return `"${identifier.replace(/"/g, '""')}"`;
-}
-
-/**
- * Escapes a string literal for safe use in SQL statements.
- *
- * Security validations:
- * - Rejects null bytes which could cause truncation or unexpected behavior
- *
- * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
- * Backslashes are treated as literal characters, not escape sequences.
- *
- * @throws {SqlEscapeError} If the value contains null bytes
- */
-export function escapeLiteral(value: string): string {
-  if (value.includes('\0')) {
-    throw new SqlEscapeError(
-      'Literal value cannot contain null bytes',
-      value.replace(/\0/g, '\\0'),
-      'literal',
-    );
-  }
-  return value.replace(/'/g, "''");
-}
-
-/**
- * Builds a qualified name (schema.object) with proper quoting.
- */
-export function qualifyName(schemaName: string, objectName: string): string {
-  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;
-}
-
-/**
- * Validates that an enum value doesn't exceed PostgreSQL's label length limit.
- *
- * PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).
- * Unlike identifiers, enum labels that exceed this limit cause an error rather than
- * silent truncation.
- *
- * @param value - The enum value to validate
- * @param enumTypeName - Name of the enum type (for error messages)
- * @throws {SqlEscapeError} If the value exceeds the maximum length
- */
-export function validateEnumValueLength(value: string, enumTypeName: string): void {
-  // PostgreSQL uses byte length, not character length. For simplicity, we use
-  // character length as a conservative approximation (multi-byte chars would fail earlier).
-  if (value.length > MAX_IDENTIFIER_LENGTH) {
-    throw new SqlEscapeError(
-      `Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ` +
-        `${MAX_IDENTIFIER_LENGTH}-character label limit`,
-      value,
-      'literal',
-    );
-  }
-}

package/src/core/standard-schema.ts

@@ -1,71 +0,0 @@
-type UnknownRecord = Record<string, unknown>;
-
-type StandardSchemaJsonSchemaField = {
-  readonly output?: unknown;
-};
-
-/**
- * Runtime view of the Standard Schema protocol.
- * Reads `~standard.jsonSchema.output` for the serializable JSON Schema representation,
- * and `.expression` for an optional TypeScript type expression string (Arktype-specific).
- *
- * This differs from the compile-time `StandardSchemaLike` in `codec-types.ts`, which reads
- * `~standard.types.output` for TypeScript type narrowing in contract.d.ts.
- */
-export type StandardSchemaLike = {
-  readonly '~standard'?: {
-    readonly version?: number;
-    readonly jsonSchema?: StandardSchemaJsonSchemaField;
-  };
-  readonly expression?: unknown;
-};
-
-function isObjectLike(value: unknown): value is UnknownRecord {
-  return (typeof value === 'object' || typeof value === 'function') && value !== null;
-}
-
-function resolveOutputJsonSchemaField(schema: StandardSchemaLike): unknown {
-  const jsonSchema = schema['~standard']?.jsonSchema;
-  if (!jsonSchema) {
-    return undefined;
-  }
-
-  if (typeof jsonSchema.output === 'function') {
-    return jsonSchema.output({
-      target: 'draft-07',
-    });
-  }
-
-  return jsonSchema.output;
-}
-
-export function extractStandardSchemaOutputJsonSchema(
-  schema: StandardSchemaLike,
-): UnknownRecord | undefined {
-  const outputSchema = resolveOutputJsonSchemaField(schema);
-  if (!isObjectLike(outputSchema)) {
-    return undefined;
-  }
-
-  return outputSchema;
-}
-
-export function extractStandardSchemaTypeExpression(
-  schema: StandardSchemaLike,
-): string | undefined {
-  const expression = schema.expression;
-  if (typeof expression !== 'string') {
-    return undefined;
-  }
-
-  const trimmedExpression = expression.trim();
-  if (trimmedExpression.length === 0) {
-    return undefined;
-  }
-
-  return trimmedExpression;
-}
-
-export function isStandardSchemaLike(value: unknown): value is StandardSchemaLike {
-  return isObjectLike(value) && isObjectLike((value as StandardSchemaLike)['~standard']);
-}

package/src/exports/codec-types.ts

@@ -1,44 +0,0 @@
-/**
- * Codec type definitions for Postgres adapter.
- *
- * This file exports type-only definitions for codec input/output types.
- * These types are imported by contract.d.ts files for compile-time type inference.
- *
- * Runtime codec implementations are provided by the adapter's codec registry.
- */
-
-import type { JsonValue } from '@prisma-next/contract/types';
-import type { CodecTypes as CoreCodecTypes } from '../core/codecs';
-
-export type CodecTypes = CoreCodecTypes;
-
-export type { JsonValue };
-export { dataTypes } from '../core/codecs';
-
-type Branded<T, Shape extends Record<string, unknown>> = T & {
-  readonly [K in keyof Shape]: Shape[K];
-};
-
-type BrandedString<Shape extends Record<string, unknown>> = Branded<string, Shape>;
-
-export type Char<N extends number> = BrandedString<{ __charLength: N }>;
-export type Varchar<N extends number> = BrandedString<{ __varcharLength: N }>;
-export type Numeric<P extends number, S extends number | undefined = undefined> = BrandedString<{
-  __numericPrecision: P;
-  __numericScale: S;
-}>;
-export type Bit<N extends number> = BrandedString<{ __bitLength: N }>;
-export type VarBit<N extends number> = BrandedString<{ __varbitLength: N }>;
-export type Timestamp<P extends number | undefined = undefined> = BrandedString<{
-  __timestampPrecision: P;
-}>;
-export type Timestamptz<P extends number | undefined = undefined> = BrandedString<{
-  __timestamptzPrecision: P;
-}>;
-export type Time<P extends number | undefined = undefined> = BrandedString<{ __timePrecision: P }>;
-export type Timetz<P extends number | undefined = undefined> = BrandedString<{
-  __timetzPrecision: P;
-}>;
-export type Interval<P extends number | undefined = undefined> = BrandedString<{
-  __intervalPrecision: P;
-}>;