@prisma-next/target-postgres 0.5.0-dev.9 → 0.5.1

package/src/core/codec-helpers.ts

@@ -0,0 +1,135 @@
+/**
+ * Shared encode/decode/render constants for the Postgres target codecs.
+ *
+ * The codec implementations live in `codecs.ts` (TML-2357). This file retains the conversion helpers + emit-path type renderers that the codec methods compose with — keeping a single source of truth for non-trivial conversions while the codec methods provide the framework-required `Promise<…>` boundary.
+ *
+ * Trivial identity passthroughs are inlined directly in the codec methods; only conversions with shape (custom JSON round-trip, decode normalisation, parameterised renderers) live here.
+ */
+
+import type { JsonValue } from '@prisma-next/contract/types';
+
+export function renderLength(
+  typeName: string,
+  typeParams: Record<string, unknown>,
+): string | undefined {
+  const length = typeParams['length'];
+  if (length === undefined) {
+    return undefined;
+  }
+  if (typeof length !== 'number' || !Number.isFinite(length) || !Number.isInteger(length)) {
+    throw new Error(
+      `renderOutputType: expected integer "length" in typeParams for ${typeName}, got ${String(length)}`,
+    );
+  }
+  return `${typeName}<${length}>`;
+}
+
+export function renderPrecision(typeName: string, typeParams: Record<string, unknown>): string {
+  const precision = typeParams['precision'];
+  if (precision === undefined) {
+    return typeName;
+  }
+  if (
+    typeof precision !== 'number' ||
+    !Number.isFinite(precision) ||
+    !Number.isInteger(precision)
+  ) {
+    throw new Error(
+      `renderOutputType: expected integer "precision" in typeParams for ${typeName}, got ${String(precision)}`,
+    );
+  }
+  return `${typeName}<${precision}>`;
+}
+
+export const pgNumericDecode = (wire: string | number): string => {
+  if (typeof wire === 'number') return String(wire);
+  return wire;
+};
+
+export const pgNumericRenderOutputType = (typeParams: {
+  readonly precision: number;
+  readonly scale?: number;
+}): string | undefined => {
+  const precision = typeParams.precision;
+  if (precision === undefined) return undefined;
+  if (
+    typeof precision !== 'number' ||
+    !Number.isFinite(precision) ||
+    !Number.isInteger(precision)
+  ) {
+    throw new Error(
+      `renderOutputType: expected integer "precision" in typeParams for Numeric, got ${String(precision)}`,
+    );
+  }
+  const scale = typeParams.scale;
+  if (scale === undefined) return `Numeric<${precision}>`;
+  if (typeof scale !== 'number' || !Number.isFinite(scale) || !Number.isInteger(scale)) {
+    throw new Error(
+      `renderOutputType: expected integer "scale" in typeParams for Numeric, got ${String(scale)}`,
+    );
+  }
+  return `Numeric<${precision}, ${scale}>`;
+};
+
+// ISO 8601 UTC: `YYYY-MM-DDTHH:MM:SS[.mmm…]Z`. Trailing `Z` is required; fractional seconds are optional. Other `Date`-parseable formats (`January 15, 2024`, `01/15/2024`, etc.) are intentionally rejected because those formats are implementation-defined and not the documented contract for `pg/timestamp@1` / `pg/timestamptz@1`.
+const ISO_8601_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/;
+
+export const pgTimestampEncodeJson = (value: Date): JsonValue => value.toISOString();
+export const pgTimestampDecodeJson = (json: JsonValue): Date => {
+  if (typeof json !== 'string') {
+    throw new Error(`Expected ISO date string for pg/timestamp@1, got ${typeof json}`);
+  }
+  if (!ISO_8601_UTC.test(json)) {
+    throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+  }
+  const date = new Date(json);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid ISO date string for pg/timestamp@1: ${json}`);
+  }
+  return date;
+};
+
+export const pgTimestamptzEncodeJson = (value: Date): JsonValue => value.toISOString();
+export const pgTimestamptzDecodeJson = (json: JsonValue): Date => {
+  if (typeof json !== 'string') {
+    throw new Error(`Expected ISO date string for pg/timestamptz@1, got ${typeof json}`);
+  }
+  if (!ISO_8601_UTC.test(json)) {
+    throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+  }
+  const date = new Date(json);
+  if (Number.isNaN(date.getTime())) {
+    throw new Error(`Invalid ISO date string for pg/timestamptz@1: ${json}`);
+  }
+  return date;
+};
+
+export const pgIntervalDecode = (wire: string | Record<string, unknown>): string => {
+  if (typeof wire === 'string') return wire;
+  return JSON.stringify(wire);
+};
+
+export const pgEnumRenderOutputType = (typeParams: {
+  readonly values?: readonly unknown[];
+}): string => {
+  const values = typeParams.values;
+  if (!Array.isArray(values)) {
+    throw new Error(
+      `renderOutputType: expected array "values" in typeParams for enum, got ${typeof values}`,
+    );
+  }
+  if (!values.every((v): v is string => typeof v === 'string')) {
+    throw new Error(`renderOutputType: expected string[] "values" in typeParams for enum`);
+  }
+  return values
+    .map((value) => `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`)
+    .join(' | ');
+};
+
+export const pgJsonEncode = (value: string | JsonValue): string => JSON.stringify(value);
+export const pgJsonDecode = (wire: string | JsonValue): JsonValue =>
+  typeof wire === 'string' ? JSON.parse(wire) : wire;
+
+export const pgJsonbEncode = (value: string | JsonValue): string => JSON.stringify(value);
+export const pgJsonbDecode = (wire: string | JsonValue): JsonValue =>
+  typeof wire === 'string' ? JSON.parse(wire) : wire;

package/src/core/codec-ids.ts

@@ -28,3 +28,4 @@ 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;
+export const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;

package/src/core/codec-type-map.ts

@@ -0,0 +1,81 @@
+/**
+ * Internal codec descriptor map and `CodecTypes` materialisation for the Postgres target.
+ *
+ * Why this lives in `core/` even though the public origin of `CodecTypes` is `exports/codec-types.ts`:
+ *
+ * - The descriptor map (`codecDescriptorMap`) and the `Resolve<T>` helper are implementation detail; they shouldn't appear on the public package surface.
+ * - The `CodecTypes` *materialisation* (the `Resolve<...>` application) must still happen at the public boundary so tsdown's DTS bundler resolves consumer-side `pack.d.mts` references via the public entry point rather than a hash-named internal chunk (the `TS2742` family). `exports/codec-types.ts` re-exports `CodecTypes` from here as a type alias, which preserves the materialisation site at the public surface.
+ */
+
+import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
+import {
+  sqlCharDescriptor,
+  sqlFloatDescriptor,
+  sqlIntDescriptor,
+  sqlTextDescriptor,
+  sqlTimestampDescriptor,
+  sqlVarcharDescriptor,
+} from '@prisma-next/sql-relational-core/ast';
+import {
+  pgBitDescriptor,
+  pgBoolDescriptor,
+  pgByteaDescriptor,
+  pgCharDescriptor,
+  pgEnumDescriptor,
+  pgFloat4Descriptor,
+  pgFloat8Descriptor,
+  pgFloatDescriptor,
+  pgInt2Descriptor,
+  pgInt4Descriptor,
+  pgInt8Descriptor,
+  pgIntDescriptor,
+  pgIntervalDescriptor,
+  pgJsonbDescriptor,
+  pgJsonDescriptor,
+  pgNumericDescriptor,
+  pgTextDescriptor,
+  pgTimeDescriptor,
+  pgTimestampDescriptor,
+  pgTimestamptzDescriptor,
+  pgTimetzDescriptor,
+  pgVarbitDescriptor,
+  pgVarcharDescriptor,
+} from './codecs';
+
+export const codecDescriptorMap = {
+  char: sqlCharDescriptor,
+  varchar: sqlVarcharDescriptor,
+  int: sqlIntDescriptor,
+  float: sqlFloatDescriptor,
+  'sql-text': sqlTextDescriptor,
+  'sql-timestamp': sqlTimestampDescriptor,
+  text: pgTextDescriptor,
+  character: pgCharDescriptor,
+  'character varying': pgVarcharDescriptor,
+  integer: pgIntDescriptor,
+  'double precision': pgFloatDescriptor,
+  int4: pgInt4Descriptor,
+  int2: pgInt2Descriptor,
+  int8: pgInt8Descriptor,
+  float4: pgFloat4Descriptor,
+  float8: pgFloat8Descriptor,
+  numeric: pgNumericDescriptor,
+  timestamp: pgTimestampDescriptor,
+  timestamptz: pgTimestamptzDescriptor,
+  time: pgTimeDescriptor,
+  timetz: pgTimetzDescriptor,
+  bool: pgBoolDescriptor,
+  bit: pgBitDescriptor,
+  'bit varying': pgVarbitDescriptor,
+  bytea: pgByteaDescriptor,
+  interval: pgIntervalDescriptor,
+  enum: pgEnumDescriptor,
+  json: pgJsonDescriptor,
+  jsonb: pgJsonbDescriptor,
+} as const;
+
+export type Resolve<T> = { readonly [K in keyof T]: { readonly [P in keyof T[K]]: T[K][P] } };
+
+export type CodecDescriptorMap = typeof codecDescriptorMap;
+
+export type ExtractedCodecTypes = ExtractCodecTypes<CodecDescriptorMap>;