@prisma-next/family-sql 0.5.0-dev.3 → 0.5.0-dev.30

package/src/core/psl-contract-infer/postgres-type-map.ts

@@ -0,0 +1,165 @@
+import type {
+  EnumInfo,
+  PslNativeTypeAttribute,
+  PslTypeMap,
+  PslTypeResolution,
+} from './printer-config';
+
+const POSTGRES_TO_PSL: Record<string, string> = {
+  text: 'String',
+  bool: 'Boolean',
+  boolean: 'Boolean',
+  int4: 'Int',
+  integer: 'Int',
+  int8: 'BigInt',
+  bigint: 'BigInt',
+  float8: 'Float',
+  'double precision': 'Float',
+  numeric: 'Decimal',
+  decimal: 'Decimal',
+  timestamptz: 'DateTime',
+  'timestamp with time zone': 'DateTime',
+  jsonb: 'Json',
+  bytea: 'Bytes',
+};
+
+const PRESERVED_NATIVE_TYPES: Record<
+  string,
+  { readonly pslType: string; readonly attributeName: string }
+> = {
+  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },
+  character: { pslType: 'String', attributeName: 'db.Char' },
+  char: { pslType: 'String', attributeName: 'db.Char' },
+  varchar: { pslType: 'String', attributeName: 'db.VarChar' },
+  uuid: { pslType: 'String', attributeName: 'db.Uuid' },
+  int2: { pslType: 'Int', attributeName: 'db.SmallInt' },
+  smallint: { pslType: 'Int', attributeName: 'db.SmallInt' },
+  float4: { pslType: 'Float', attributeName: 'db.Real' },
+  real: { pslType: 'Float', attributeName: 'db.Real' },
+  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },
+  'timestamp without time zone': { pslType: 'DateTime', attributeName: 'db.Timestamp' },
+  date: { pslType: 'DateTime', attributeName: 'db.Date' },
+  time: { pslType: 'DateTime', attributeName: 'db.Time' },
+  'time without time zone': { pslType: 'DateTime', attributeName: 'db.Time' },
+  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },
+  'time with time zone': { pslType: 'DateTime', attributeName: 'db.Timetz' },
+  json: { pslType: 'Json', attributeName: 'db.Json' },
+};
+
+const PARAMETERIZED_NATIVE_TYPES: Record<
+  string,
+  { readonly pslType: string; readonly attributeName: string }
+> = {
+  'character varying': { pslType: 'String', attributeName: 'db.VarChar' },
+  character: { pslType: 'String', attributeName: 'db.Char' },
+  char: { pslType: 'String', attributeName: 'db.Char' },
+  varchar: { pslType: 'String', attributeName: 'db.VarChar' },
+  numeric: { pslType: 'Decimal', attributeName: 'db.Numeric' },
+  timestamp: { pslType: 'DateTime', attributeName: 'db.Timestamp' },
+  timestamptz: { pslType: 'DateTime', attributeName: 'db.Timestamptz' },
+  time: { pslType: 'DateTime', attributeName: 'db.Time' },
+  timetz: { pslType: 'DateTime', attributeName: 'db.Timetz' },
+};
+
+const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
+
+const ENUM_CODEC_ID = 'pg/enum@1';
+
+function getOwnMappingValue(map: Record<string, string>, key: string): string | undefined {
+  return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
+function getOwnRecordValue<T>(map: Record<string, T>, key: string): T | undefined {
+  return Object.hasOwn(map, key) ? map[key] : undefined;
+}
+
+function createNativeTypeAttribute(name: string, args?: readonly string[]): PslNativeTypeAttribute {
+  return args && args.length > 0 ? { name, args } : { name };
+}
+
+function splitTypeParameterList(params: string): readonly string[] {
+  return params
+    .split(',')
+    .map((part) => part.trim())
+    .filter((part) => part.length > 0);
+}
+
+export function createPostgresTypeMap(enumTypeNames?: ReadonlySet<string>): PslTypeMap {
+  return {
+    resolve(nativeType: string): PslTypeResolution {
+      if (enumTypeNames?.has(nativeType)) {
+        return { pslType: nativeType, nativeType };
+      }
+
+      const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
+      if (paramMatch) {
+        const [, baseType = nativeType, params = ''] = paramMatch;
+        const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
+        if (template) {
+          return {
+            pslType: template.pslType,
+            nativeType,
+            typeParams: { baseType, params },
+            nativeTypeAttribute: createNativeTypeAttribute(
+              template.attributeName,
+              splitTypeParameterList(params),
+            ),
+          };
+        }
+      }
+
+      const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
+      if (preservedType) {
+        return {
+          pslType: preservedType.pslType,
+          nativeType,
+          nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName),
+        };
+      }
+
+      const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
+      if (pslType) {
+        return {
+          pslType,
+          nativeType,
+        };
+      }
+
+      return { unsupported: true, nativeType };
+    },
+  };
+}
+
+export function extractEnumInfo(annotations?: Record<string, unknown>): EnumInfo {
+  const pgAnnotations = annotations?.['pg'] as Record<string, unknown> | undefined;
+  const storageTypes = pgAnnotations?.['storageTypes'] as
+    | Record<string, { codecId: string; nativeType: string; typeParams?: Record<string, unknown> }>
+    | undefined;
+
+  const typeNames = new Set<string>();
+  const definitions = new Map<string, readonly string[]>();
+
+  if (storageTypes) {
+    for (const [key, typeInstance] of Object.entries(storageTypes)) {
+      if (typeInstance.codecId === ENUM_CODEC_ID) {
+        typeNames.add(key);
+        const values = typeInstance.typeParams?.['values'];
+        if (Array.isArray(values)) {
+          definitions.set(key, values as string[]);
+        }
+      }
+    }
+  }
+
+  return { typeNames, definitions };
+}
+
+export function extractEnumTypeNames(annotations?: Record<string, unknown>): ReadonlySet<string> {
+  return extractEnumInfo(annotations).typeNames;
+}
+
+export function extractEnumDefinitions(
+  annotations?: Record<string, unknown>,
+): ReadonlyMap<string, readonly string[]> {
+  return extractEnumInfo(annotations).definitions;
+}

package/src/core/psl-contract-infer/printer-config.ts

@@ -0,0 +1,55 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+import type { DefaultMappingOptions } from './default-mapping';
+
+/**
+ * Internal printer-shaped configuration, used by the SQL family's
+ * `sqlSchemaIrToPslAst` helper (M2). The framework-level psl-printer no longer
+ * exposes these — they're consumed only inside the SQL family.
+ */
+
+export type PslNativeTypeAttribute = {
+  readonly name: string;
+  readonly args?: readonly string[];
+};
+
+export type PslTypeResolution =
+  | {
+      readonly pslType: string;
+      readonly nativeType: string;
+      readonly typeParams?: Record<string, unknown>;
+      readonly nativeTypeAttribute?: PslNativeTypeAttribute;
+    }
+  | {
+      readonly unsupported: true;
+      readonly nativeType: string;
+    };
+
+export interface PslTypeMap {
+  resolve(nativeType: string, annotations?: Record<string, unknown>): PslTypeResolution;
+}
+
+export interface EnumInfo {
+  readonly typeNames: ReadonlySet<string>;
+  readonly definitions: ReadonlyMap<string, readonly string[]>;
+}
+
+export interface PslPrinterOptions {
+  readonly typeMap: PslTypeMap;
+  readonly defaultMapping?: DefaultMappingOptions;
+  readonly enumInfo?: EnumInfo;
+  readonly parseRawDefault?: (rawDefault: string, nativeType?: string) => ColumnDefault | undefined;
+}
+
+export type RelationField = {
+  readonly fieldName: string;
+  readonly typeName: string;
+  readonly referencedTableName?: string | undefined;
+  readonly optional: boolean;
+  readonly list: boolean;
+  readonly relationName?: string | undefined;
+  readonly fkName?: string | undefined;
+  readonly fields?: readonly string[] | undefined;
+  readonly references?: readonly string[] | undefined;
+  readonly onDelete?: string | undefined;
+  readonly onUpdate?: string | undefined;
+};

package/src/core/psl-contract-infer/raw-default-parser.ts

@@ -0,0 +1,91 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+
+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 JSON_CAST_SUFFIX = /::jsonb?$/i;
+const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
+
+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();
+  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()';
+
+  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();
+  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';
+
+  return undefined;
+}
+
+export function parseRawDefault(
+  rawDefault: string,
+  nativeType?: string,
+): ColumnDefault | undefined {
+  const trimmed = rawDefault.trim();
+  const normalizedType = nativeType?.toLowerCase();
+
+  if (NEXTVAL_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'autoincrement()' };
+  }
+
+  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
+  if (canonicalTimestamp) {
+    return { kind: 'function', expression: canonicalTimestamp };
+  }
+
+  if (UUID_PATTERN.test(trimmed) || UUID_OSSP_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'gen_random_uuid()' };
+  }
+
+  if (NULL_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: null };
+  }
+
+  if (TRUE_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: true };
+  }
+
+  if (FALSE_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: false };
+  }
+
+  if (NUMERIC_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: Number(trimmed) };
+  }
+
+  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
+  if (stringMatch?.[1] !== undefined) {
+    const unescaped = stringMatch[1].replace(/''/g, "'");
+    if (normalizedType === 'json' || normalizedType === 'jsonb') {
+      if (JSON_CAST_SUFFIX.test(trimmed)) {
+        return { kind: 'function', expression: trimmed };
+      }
+      try {
+        return { kind: 'literal', value: JSON.parse(unescaped) };
+      } catch {
+        // Fall through to the string form for malformed/non-JSON values.
+      }
+    }
+    return { kind: 'literal', value: unescaped };
+  }
+
+  return { kind: 'function', expression: trimmed };
+}

package/src/core/psl-contract-infer/relation-inference.ts

@@ -0,0 +1,196 @@
+import type { SqlForeignKeyIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
+import { deriveBackRelationFieldName, deriveRelationFieldName, pluralize } from './name-transforms';
+import type { RelationField } from './printer-config';
+
+const DEFAULT_ON_DELETE = 'noAction';
+const DEFAULT_ON_UPDATE = 'noAction';
+
+const REFERENTIAL_ACTION_PSL: Record<string, string> = {
+  noAction: 'NoAction',
+  restrict: 'Restrict',
+  cascade: 'Cascade',
+  setNull: 'SetNull',
+  setDefault: 'SetDefault',
+};
+
+export type InferredRelations = {
+  readonly relationsByTable: ReadonlyMap<string, readonly RelationField[]>;
+};
+
+export function inferRelations(
+  tables: Record<string, SqlTableIR>,
+  modelNameMap: ReadonlyMap<string, string>,
+): InferredRelations {
+  const relationsByTable = new Map<string, RelationField[]>();
+
+  const fkCountByPair = new Map<string, number>();
+  for (const table of Object.values(tables)) {
+    for (const fk of table.foreignKeys) {
+      const pairKey = `${table.name}→${fk.referencedTable}`;
+      fkCountByPair.set(pairKey, (fkCountByPair.get(pairKey) ?? 0) + 1);
+    }
+  }
+
+  const usedFieldNames = new Map<string, Set<string>>();
+  for (const table of Object.values(tables)) {
+    const names = new Set<string>();
+    for (const col of Object.values(table.columns)) {
+      names.add(col.name);
+    }
+    usedFieldNames.set(table.name, names);
+  }
+
+  for (const table of Object.values(tables)) {
+    for (const fk of table.foreignKeys) {
+      const childTableName = table.name;
+      const parentTableName = fk.referencedTable;
+      const childUsed = usedFieldNames.get(childTableName) as Set<string>;
+      const childModelName = modelNameMap.get(childTableName) ?? childTableName;
+      const parentModelName = modelNameMap.get(parentTableName) ?? parentTableName;
+      const pairKey = `${childTableName}→${parentTableName}`;
+      const isSelfRelation = childTableName === parentTableName;
+      const needsRelationName = (fkCountByPair.get(pairKey) as number) > 1 || isSelfRelation;
+
+      const isOneToOne = detectOneToOne(fk, table);
+
+      const childRelFieldName = resolveUniqueFieldName(
+        deriveRelationFieldName(fk.columns, parentTableName),
+        childUsed,
+        parentModelName,
+      );
+      const relationName = needsRelationName
+        ? deriveRelationName(fk, childRelFieldName, parentModelName, isSelfRelation)
+        : undefined;
+      const childOptional = fk.columns.some(
+        (columnName) => table.columns[columnName]?.nullable ?? false,
+      );
+
+      const childRelField = buildChildRelationField(
+        childRelFieldName,
+        parentModelName,
+        fk,
+        childOptional,
+        relationName,
+      );
+
+      addRelationField(relationsByTable, childTableName, childRelField);
+      childUsed.add(childRelFieldName);
+
+      const parentUsed = usedFieldNames.get(parentTableName) ?? new Set();
+      usedFieldNames.set(parentTableName, parentUsed);
+
+      const backRelFieldName = resolveUniqueFieldName(
+        deriveBackRelationFieldName(childModelName, isOneToOne),
+        parentUsed,
+        childModelName,
+      );
+
+      const backRelField: RelationField = {
+        fieldName: backRelFieldName,
+        typeName: childModelName,
+        optional: isOneToOne,
+        list: !isOneToOne,
+        relationName,
+      };
+
+      addRelationField(relationsByTable, parentTableName, backRelField);
+      parentUsed.add(backRelFieldName);
+    }
+  }
+
+  return { relationsByTable };
+}
+
+function detectOneToOne(fk: SqlForeignKeyIR, table: SqlTableIR): boolean {
+  const fkCols = [...fk.columns].sort();
+
+  if (table.primaryKey) {
+    const pkCols = [...table.primaryKey.columns].sort();
+    if (pkCols.length === fkCols.length && pkCols.every((c, i) => c === fkCols[i])) {
+      return true;
+    }
+  }
+
+  for (const unique of table.uniques) {
+    const uniqueCols = [...unique.columns].sort();
+    if (uniqueCols.length === fkCols.length && uniqueCols.every((c, i) => c === fkCols[i])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function deriveRelationName(
+  fk: SqlForeignKeyIR,
+  childRelationFieldName: string,
+  parentModelName: string,
+  isSelfRelation: boolean,
+): string {
+  if (fk.name) {
+    return fk.name;
+  }
+  if (isSelfRelation) {
+    return `${childRelationFieldName.charAt(0).toUpperCase() + childRelationFieldName.slice(1)}${pluralize(parentModelName)}`;
+  }
+  return fk.columns.join('_');
+}
+
+function buildChildRelationField(
+  fieldName: string,
+  parentModelName: string,
+  fk: SqlForeignKeyIR,
+  optional: boolean,
+  relationName?: string,
+): RelationField {
+  const onDelete = fk.onDelete && fk.onDelete !== DEFAULT_ON_DELETE ? fk.onDelete : undefined;
+  const onUpdate = fk.onUpdate && fk.onUpdate !== DEFAULT_ON_UPDATE ? fk.onUpdate : undefined;
+
+  return {
+    fieldName,
+    typeName: parentModelName,
+    referencedTableName: fk.referencedTable,
+    optional,
+    list: false,
+    relationName,
+    fkName: fk.name,
+    fields: fk.columns,
+    references: fk.referencedColumns,
+    onDelete: onDelete ? REFERENTIAL_ACTION_PSL[onDelete] : undefined,
+    onUpdate: onUpdate ? REFERENTIAL_ACTION_PSL[onUpdate] : undefined,
+  };
+}
+
+function resolveUniqueFieldName(
+  desired: string,
+  usedNames: ReadonlySet<string>,
+  fallbackSuffix: string,
+): string {
+  if (!usedNames.has(desired)) {
+    return desired;
+  }
+
+  const withSuffix = `${desired}${fallbackSuffix}`;
+  if (!usedNames.has(withSuffix)) {
+    return withSuffix;
+  }
+
+  let counter = 2;
+  while (usedNames.has(`${desired}${counter}`)) {
+    counter++;
+  }
+  return `${desired}${counter}`;
+}
+
+function addRelationField(
+  map: Map<string, RelationField[]>,
+  tableName: string,
+  field: RelationField,
+): void {
+  const existing = map.get(tableName);
+  if (existing) {
+    existing.push(field);
+  } else {
+    map.set(tableName, [field]);
+  }
+}